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

#define SWIGRUBY
#define SWIG_DIRECTORS

#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};
#endif

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

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC)
#   if (__SUNPRO_CC <= 0x560)
#     define SWIGTEMPLATEDISAMBIGUATOR template
#   else
#     define SWIGTEMPLATEDISAMBIGUATOR 
#   endif
# else
#   define SWIGTEMPLATEDISAMBIGUATOR 
# endif
#endif

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

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

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

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

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

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

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

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

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

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

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC)
#   if (__SUNPRO_CC <= 0x560)
#     define SWIGTEMPLATEDISAMBIGUATOR template
#   else
#     define SWIGTEMPLATEDISAMBIGUATOR 
#   endif
# else
#   define SWIGTEMPLATEDISAMBIGUATOR 
# endif
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

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

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


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

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

   Now you can be more explicit as:

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

   that seems to be the same, but now you can also do

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

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

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

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

       int food(double)
       int fooi(int);

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

   just use the SWIG_AddCast()/SWIG_CheckState()


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

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


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




#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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


/* think of this as a c++ template<> or a scheme macro */
#define SWIG_TypeCheck_Template(comparison, ty)         \
  if (ty) {                                             \
    swig_cast_info *iter = ty->cast;                    \
    while (iter) {                                      \
      if (comparison) {                                 \
        if (iter == ty->cast) return iter;              \
        /* Move iter to the top of the linked list */   \
        iter->prev->next = iter->next;                  \
        if (iter->next)                                 \
          iter->next->prev = iter->prev;                \
        iter->next = ty->cast;                          \
        iter->prev = 0;                                 \
        if (ty->cast) ty->cast->prev = iter;            \
        ty->cast = iter;                                \
        return iter;                                    \
      }                                                 \
      iter = iter->next;                                \
    }                                                   \
  }                                                     \
  return 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



#include <ruby.h>

/* 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 RARRAY_LEN
# define RARRAY_LEN(x) RARRAY(x)->len
#endif
#ifndef RARRAY_PTR
# define RARRAY_PTR(x) RARRAY(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


/* -----------------------------------------------------------------------------
 * 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 funtion 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;
}




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


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

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

/* 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.  Also make sure to tell
     the garabage collector about the hash table. */
  swig_ruby_trackings = rb_hash_new();
  rb_gc_register_address(&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 */
  unsigned long value = (unsigned long) ptr;
  return LONG2NUM(value);
}

/* 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 */
  unsigned long value = (unsigned long) object;
  return LONG2NUM(value);
}

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

  /* First convert the Ruby number to a C number */
  unsigned long value = NUM2LONG(reference);
  return (VALUE) value;
}

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

#ifdef __cplusplus
}
#endif


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


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

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

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


static VALUE _mSWIG = Qnil;
static VALUE _cSWIG_Pointer = Qnil;
static VALUE swig_runtime_data_type_pointer = Qnil;

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

/* 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; 
  
  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? */
    if (sklass->trackObjects) {
      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) : 0), ptr);

    /* If tracking is on for this class then track this object. */
    if (sklass->trackObjects) {
      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;
    }
    *ptr = SWIG_TypeCast(tc, vptr);
  } 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);
}

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



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

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



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

/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * director.swg
 *
 * This file contains support for director classes that proxy
 * method calls from C++ to 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>

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> ownership_map;
    mutable ownership_map owner;
#ifdef __PTHREAD__
    static pthread_mutex_t swig_mutex_own;
#endif

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

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

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

#define SWIG_init    Init_quickfix
#define SWIG_name    "Quickfix"

static VALUE mQuickfix;

#define SWIGVERSION 0x010331 
#define SWIG_VERSION SWIGVERSION


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


#include <stdexcept>


#ifdef __cplusplus
extern "C" {
#endif
#include "rubyio.h"
#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:%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>
#ifndef LLONG_MIN
# define LLONG_MIN	LONG_LONG_MIN
#endif
#ifndef LLONG_MAX
# define LLONG_MAX	LONG_LONG_MAX
#endif
#ifndef ULLONG_MAX
# define ULLONG_MAX	ULONG_LONG_MAX
#endif


  #define SWIG_From_long   LONG2NUM 


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


/*@SWIG:%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;


#ifdef SWIGPYTHON
import thread

def _quickfix_start_thread(i_or_a):
	i_or_a.block()
#endif


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) {
    


    char *cstr = STR2CSTR(obj);
    
    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)
{
  if (s.size()) {
    return SWIG_FromCharPtrAndSize(s.data(), s.size());
  } else {
    return SWIG_FromCharPtrAndSize(s.c_str(), 0);
  }
}

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

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

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




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:%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  double *res = (double *)(args[1]);
  *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(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();
  }

#ifdef SWIGPYTHON
class SocketInitiator(SocketInitiatorBase):
	application = 0
	storeFactory = 0
	setting = 0
	logFactory = 0

	def __init__(self, application, storeFactory, settings, logFactory=None):
		if logFactory == None:
			SocketInitiatorBase.__init__(self, application, storeFactory, settings)
		else:
			SocketInitiatorBase.__init__(self, application, storeFactory, settings, logFactory)

		self.application = application
		self.storeFactory = storeFactory
		self.settings = settings
		self.logFactory = logFactory

class SocketAcceptor(SocketAcceptorBase):
	application = 0
	storeFactory = 0
	setting = 0
	logFactory = 0

	def __init__(self, application, storeFactory, settings, logFactory=None):
		if logFactory == None:
			SocketAcceptorBase.__init__(self, application, storeFactory, settings)
		else:
			SocketAcceptorBase.__init__(self, application, storeFactory, settings, logFactory)

		self.application = application
		self.storeFactory = storeFactory
		self.settings = settings
		self.logFactory = logFactory
#endif

/* ---------------------------------------------------
 * 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) {
  if (Application_onCreate_call_depth == 1) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
    
    
    
    
    
    
    
    
    
  }
  Application_onCreate_call_depth--;
  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) {
  if (Application_onLogon_call_depth == 1) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
    
    
    
    
    
    
    
    
    
  }
  Application_onLogon_call_depth--;
  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) {
  if (Application_onLogout_call_depth == 1) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
    
    
    
    
    
    
    
    
    
  }
  Application_onLogout_call_depth--;
  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) {
  if (Application_toAdmin_call_depth == 1) {
    if( error != 0 ) {
      VALUE message = rb_obj_as_string( error );
      printf( "%s\n", RSTRING(message)->ptr );
      exit(1);
    }
    
    
    
    
    
    
    
    
    
    
  }
  Application_toAdmin_call_depth--;
  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) {
  if (Application_toApp_call_depth == 1) {
    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);
      }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  }
  Application_toApp_call_depth--;
  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) {
  if (Application_fromAdmin_call_depth == 1) {
    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);
      }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  }
  Application_fromAdmin_call_depth--;
  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) {
  if (Application_fromApp_call_depth == 1) {
    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);
      }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  }
  Application_fromApp_call_depth--;
  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 cIntArray;

#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 ;
  IntArray *result = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IntArray";
  
  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), "in method '" "IntArray" "', argument " "1"" of type '" "size_t""'");
  } 
  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);
}

SWIGINTERN VALUE
_wrap_IntArray___getitem__(int argc, VALUE *argv, VALUE self) {
  IntArray *arg1 = (IntArray *) 0 ;
  size_t arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_IntArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__getitem__" "', argument " "1"" of type '" "IntArray *""'"); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__getitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  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;
}


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), "in method '" "__setitem__" "', argument " "1"" of type '" "IntArray *""'"); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__setitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__setitem__" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  int *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "cast" "', argument " "1"" of type '" "IntArray *""'"); 
  }
  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 ;
  IntArray *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "IntArray_frompointer" "', argument " "1"" of type '" "int *""'"); 
  }
  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 cException;

#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 ;
  FIX::Exception *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::Exception";
  
  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), "in method '" "FIX::Exception" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Exception" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::Exception" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Exception" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "type" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  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), "in method '" "type" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "type" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "type" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    std::string const &_result_ref =  ((arg1)->type);
    result = (std::string *) &_result_ref;
  }
  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), "in method '" "detail" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  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), "in method '" "detail" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "detail" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "detail" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    std::string const &_result_ref =  ((arg1)->detail);
    result = (std::string *) &_result_ref;
  }
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "__str__" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  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 cDataDictionaryNotFound;

SWIGINTERN VALUE
_wrap_new_DataDictionaryNotFound__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  FIX::DataDictionaryNotFound *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionaryNotFound";
  
  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), "in method '" "FIX::DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::DataDictionaryNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DataDictionaryNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::DataDictionaryNotFound *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionaryNotFound";
  
  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), "in method '" "FIX::DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DataDictionaryNotFound'");
  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), "in method '" "version" "', argument " "1"" of type '" "FIX::DataDictionaryNotFound *""'"); 
  }
  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), "in method '" "version" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "version" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "version" "', argument " "1"" of type '" "FIX::DataDictionaryNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionaryNotFound * >(argp1);
  {
    std::string const &_result_ref =  ((arg1)->version);
    result = (std::string *) &_result_ref;
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class cFieldNotFound;

SWIGINTERN VALUE
_wrap_new_FieldNotFound__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::FieldNotFound *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FieldNotFound";
  
  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), "in method '" "FIX::FieldNotFound" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::FieldNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FieldNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::FieldNotFound *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldNotFound";
  
  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), "in method '" "FIX::FieldNotFound" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::FieldNotFound *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldNotFound";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FieldNotFound'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::FieldNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldNotFound * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__FieldNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::FieldNotFound *""'"); 
  }
  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 cFieldConvertError;

SWIGINTERN VALUE
_wrap_new_FieldConvertError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::FieldConvertError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FieldConvertError";
  
  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), "in method '" "FIX::FieldConvertError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FieldConvertError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::FieldConvertError *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldConvertError";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FieldConvertError'");
  return Qnil;
}


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

swig_class cMessageParseError;

SWIGINTERN VALUE
_wrap_new_MessageParseError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::MessageParseError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::MessageParseError";
  
  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), "in method '" "FIX::MessageParseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MessageParseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::MessageParseError *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageParseError";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MessageParseError'");
  return Qnil;
}


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

swig_class cInvalidMessage;

SWIGINTERN VALUE
_wrap_new_InvalidMessage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::InvalidMessage *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessage";
  
  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), "in method '" "FIX::InvalidMessage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InvalidMessage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::InvalidMessage *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessage";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InvalidMessage'");
  return Qnil;
}


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

swig_class cConfigError;

SWIGINTERN VALUE
_wrap_new_ConfigError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::ConfigError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::ConfigError";
  
  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), "in method '" "FIX::ConfigError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfigError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::ConfigError *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfigError";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfigError'");
  return Qnil;
}


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

swig_class cRuntimeError;

SWIGINTERN VALUE
_wrap_new_RuntimeError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::RuntimeError *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RuntimeError";
  
  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), "in method '" "FIX::RuntimeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RuntimeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::RuntimeError *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RuntimeError";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RuntimeError'");
  return Qnil;
}


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

swig_class cInvalidTagNumber;

SWIGINTERN VALUE
_wrap_new_InvalidTagNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::InvalidTagNumber *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidTagNumber";
  
  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), "in method '" "FIX::InvalidTagNumber" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::InvalidTagNumber" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InvalidTagNumber" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::InvalidTagNumber *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidTagNumber";
  
  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), "in method '" "FIX::InvalidTagNumber" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::InvalidTagNumber *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidTagNumber";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InvalidTagNumber'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::InvalidTagNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InvalidTagNumber * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__InvalidTagNumber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::InvalidTagNumber *""'"); 
  }
  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 cRequiredTagMissing;

SWIGINTERN VALUE
_wrap_new_RequiredTagMissing__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::RequiredTagMissing *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RequiredTagMissing";
  
  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), "in method '" "FIX::RequiredTagMissing" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::RequiredTagMissing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RequiredTagMissing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::RequiredTagMissing *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RequiredTagMissing";
  
  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), "in method '" "FIX::RequiredTagMissing" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::RequiredTagMissing *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RequiredTagMissing";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RequiredTagMissing'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::RequiredTagMissing *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RequiredTagMissing * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__RequiredTagMissing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::RequiredTagMissing *""'"); 
  }
  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 cTagNotDefinedForMessage;

SWIGINTERN VALUE
_wrap_new_TagNotDefinedForMessage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::TagNotDefinedForMessage";
  
  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), "in method '" "FIX::TagNotDefinedForMessage" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::TagNotDefinedForMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TagNotDefinedForMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TagNotDefinedForMessage";
  
  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), "in method '" "FIX::TagNotDefinedForMessage" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::TagNotDefinedForMessage *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TagNotDefinedForMessage";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TagNotDefinedForMessage'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::TagNotDefinedForMessage *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagNotDefinedForMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__TagNotDefinedForMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::TagNotDefinedForMessage *""'"); 
  }
  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 cNoTagValue;

SWIGINTERN VALUE
_wrap_new_NoTagValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::NoTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::NoTagValue";
  
  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), "in method '" "FIX::NoTagValue" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::NoTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::NoTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTagValue";
  
  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), "in method '" "FIX::NoTagValue" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::NoTagValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTagValue";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTagValue'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::NoTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTagValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__NoTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::NoTagValue *""'"); 
  }
  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 cIncorrectTagValue;

SWIGINTERN VALUE
_wrap_new_IncorrectTagValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::IncorrectTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectTagValue";
  
  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), "in method '" "FIX::IncorrectTagValue" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::IncorrectTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IncorrectTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::IncorrectTagValue *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectTagValue";
  
  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), "in method '" "FIX::IncorrectTagValue" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::IncorrectTagValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectTagValue";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IncorrectTagValue'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::IncorrectTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectTagValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__IncorrectTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::IncorrectTagValue *""'"); 
  }
  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 cIncorrectDataFormat;

SWIGINTERN VALUE
_wrap_new_IncorrectDataFormat__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::IncorrectDataFormat *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectDataFormat";
  
  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), "in method '" "FIX::IncorrectDataFormat" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::IncorrectDataFormat" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IncorrectDataFormat" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::IncorrectDataFormat *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectDataFormat";
  
  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), "in method '" "FIX::IncorrectDataFormat" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::IncorrectDataFormat *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectDataFormat";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IncorrectDataFormat'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::IncorrectDataFormat *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectDataFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__IncorrectDataFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::IncorrectDataFormat *""'"); 
  }
  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 cIncorrectMessageStructure;

SWIGINTERN VALUE
_wrap_new_IncorrectMessageStructure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::IncorrectMessageStructure *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectMessageStructure";
  
  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), "in method '" "FIX::IncorrectMessageStructure" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IncorrectMessageStructure" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::IncorrectMessageStructure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncorrectMessageStructure";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IncorrectMessageStructure'");
  return Qnil;
}


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

swig_class cDuplicateFieldNumber;

SWIGINTERN VALUE
_wrap_new_DuplicateFieldNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::DuplicateFieldNumber *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DuplicateFieldNumber";
  
  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), "in method '" "FIX::DuplicateFieldNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DuplicateFieldNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::DuplicateFieldNumber *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DuplicateFieldNumber";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DuplicateFieldNumber'");
  return Qnil;
}


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

swig_class cInvalidMessageType;

SWIGINTERN VALUE
_wrap_new_InvalidMessageType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::InvalidMessageType *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessageType";
  
  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), "in method '" "FIX::InvalidMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InvalidMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::InvalidMessageType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvalidMessageType";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InvalidMessageType'");
  return Qnil;
}


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

swig_class cUnsupportedMessageType;

SWIGINTERN VALUE
_wrap_new_UnsupportedMessageType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::UnsupportedMessageType *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedMessageType";
  
  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), "in method '" "FIX::UnsupportedMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnsupportedMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::UnsupportedMessageType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedMessageType";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnsupportedMessageType'");
  return Qnil;
}


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

swig_class cUnsupportedVersion;

SWIGINTERN VALUE
_wrap_new_UnsupportedVersion__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::UnsupportedVersion *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedVersion";
  
  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), "in method '" "FIX::UnsupportedVersion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnsupportedVersion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::UnsupportedVersion *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnsupportedVersion";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnsupportedVersion'");
  return Qnil;
}


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

swig_class cTagOutOfOrder;

SWIGINTERN VALUE
_wrap_new_TagOutOfOrder__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::TagOutOfOrder *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::TagOutOfOrder";
  
  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), "in method '" "FIX::TagOutOfOrder" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::TagOutOfOrder" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TagOutOfOrder" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::TagOutOfOrder *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TagOutOfOrder";
  
  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), "in method '" "FIX::TagOutOfOrder" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::TagOutOfOrder *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TagOutOfOrder";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TagOutOfOrder'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::TagOutOfOrder *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagOutOfOrder * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__TagOutOfOrder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::TagOutOfOrder *""'"); 
  }
  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 cRepeatedTag;

SWIGINTERN VALUE
_wrap_new_RepeatedTag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::RepeatedTag *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatedTag";
  
  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), "in method '" "FIX::RepeatedTag" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::RepeatedTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RepeatedTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::RepeatedTag *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatedTag";
  
  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), "in method '" "FIX::RepeatedTag" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::RepeatedTag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatedTag";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RepeatedTag'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::RepeatedTag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatedTag * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__RepeatedTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::RepeatedTag *""'"); 
  }
  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 cRepeatingGroupCountMismatch;

SWIGINTERN VALUE
_wrap_new_RepeatingGroupCountMismatch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatingGroupCountMismatch";
  
  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), "in method '" "FIX::RepeatingGroupCountMismatch" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::RepeatingGroupCountMismatch" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RepeatingGroupCountMismatch" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatingGroupCountMismatch";
  
  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), "in method '" "FIX::RepeatingGroupCountMismatch" "', argument " "1"" of type '" "int""'");
  } 
  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) {
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepeatingGroupCountMismatch";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RepeatingGroupCountMismatch'");
  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), "in method '" "field" "', argument " "1"" of type '" "FIX::RepeatingGroupCountMismatch *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatingGroupCountMismatch * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "field" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__RepeatingGroupCountMismatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::RepeatingGroupCountMismatch *""'"); 
  }
  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 cDoNotSend;

SWIGINTERN VALUE
_wrap_new_DoNotSend__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::DoNotSend *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DoNotSend";
  
  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), "in method '" "FIX::DoNotSend" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DoNotSend" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::DoNotSend *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DoNotSend";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DoNotSend'");
  return Qnil;
}


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

swig_class cRejectLogon;

SWIGINTERN VALUE
_wrap_new_RejectLogon__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::RejectLogon *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::RejectLogon";
  
  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), "in method '" "FIX::RejectLogon" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RejectLogon" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::RejectLogon *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RejectLogon";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RejectLogon'");
  return Qnil;
}


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

swig_class cSessionNotFound;

SWIGINTERN VALUE
_wrap_new_SessionNotFound__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::SessionNotFound *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SessionNotFound";
  
  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), "in method '" "FIX::SessionNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::SessionNotFound *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionNotFound";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SessionNotFound'");
  return Qnil;
}


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

swig_class cIOException;

SWIGINTERN VALUE
_wrap_new_IOException__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::IOException *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::IOException";
  
  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), "in method '" "FIX::IOException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::IOException *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOException";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOException'");
  return Qnil;
}


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

swig_class cSocketException;

SWIGINTERN VALUE
_wrap_new_SocketException__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SocketException *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketException";
  
  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 ;
  FIX::SocketException *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketException";
  
  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), "in method '" "FIX::SocketException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SocketException'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SocketException_errorToWhat(int argc, VALUE *argv, VALUE self) {
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorToWhat" "', argument " "1"" of type '" "FIX::SocketException *""'"); 
  }
  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), "in method '" "error" "', argument " "1"" of type '" "FIX::SocketException *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "error" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "error" "', argument " "1"" of type '" "FIX::SocketException *""'"); 
  }
  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 cSocketSendFailed;

SWIGINTERN VALUE
_wrap_new_SocketSendFailed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SocketSendFailed *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketSendFailed";
  
  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 ;
  FIX::SocketSendFailed *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketSendFailed";
  
  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), "in method '" "FIX::SocketSendFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketSendFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SocketSendFailed'");
  return Qnil;
}


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

swig_class cSocketRecvFailed;

SWIGINTERN VALUE
_wrap_new_SocketRecvFailed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  FIX::SocketRecvFailed *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketRecvFailed";
  
  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), "in method '" "FIX::SocketRecvFailed" "', argument " "1"" of type '" "int""'");
  } 
  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 ;
  FIX::SocketRecvFailed *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketRecvFailed";
  
  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), "in method '" "FIX::SocketRecvFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketRecvFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SocketRecvFailed'");
  return Qnil;
}


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

swig_class cSocketCloseFailed;

SWIGINTERN VALUE
_wrap_new_SocketCloseFailed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SocketCloseFailed *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketCloseFailed";
  
  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 ;
  FIX::SocketCloseFailed *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SocketCloseFailed";
  
  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), "in method '" "FIX::SocketCloseFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketCloseFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SocketCloseFailed'");
  return Qnil;
}


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

swig_class cFieldBase;

#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 ;
  FIX::FieldBase *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FieldBase";
  
  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), "in method '" "FIX::FieldBase" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::FieldBase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FieldBase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "setField" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setString" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  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), "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getField" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getString" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    std::string const &_result_ref = ((FIX::FieldBase const *)arg1)->getString();
    result = (std::string *) &_result_ref;
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldBase_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getValue" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    std::string const &_result_ref = ((FIX::FieldBase const *)arg1)->getValue();
    result = (std::string *) &_result_ref;
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getLength" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getTotal" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap_FieldBase___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator <" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  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), "in method '" "operator <" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator <" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "__str__" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap___lshift____SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::FieldBase *arg2 = 0 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  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), "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::FieldBase const &)*arg2);
    result = (std::ostream *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class cStringField;

SWIGINTERN VALUE
_wrap_new_StringField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  std::string *arg2 = 0 ;
  FIX::StringField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::StringField";
  
  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), "in method '" "FIX::StringField" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::StringField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StringField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::StringField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StringField";
  
  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), "in method '" "FIX::StringField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StringField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::StringField *""'"); 
  }
  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), "in method '" "setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getValue" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    std::string const &_result_ref = ((FIX::StringField const *)arg1)->getValue();
    result = (std::string *) &_result_ref;
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator <" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  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), "in method '" "operator <" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator <" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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 VALUE
_wrap_StringField___gt__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator >" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  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), "in method '" "operator >" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator >" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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 VALUE
_wrap_StringField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator ==" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  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), "in method '" "operator ==" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator ==" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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 VALUE
_wrap_StringField___le__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator <=" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  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), "in method '" "operator <=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator <=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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 VALUE
_wrap_StringField___ge__(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator >=" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  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), "in method '" "operator >=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator >=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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;
}

SWIGINTERN VALUE
_wrap___lt____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator <" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator <" "', argument " "2"" of type '" "char const *""'");
  }
  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 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  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), "in method '" "FIX::operator <" "', argument " "1"" of type '" "char const *""'");
  }
  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), "in method '" "FIX::operator <" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap___gt____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator >" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator >" "', argument " "2"" of type '" "char const *""'");
  }
  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 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  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), "in method '" "FIX::operator >" "', argument " "1"" of type '" "char const *""'");
  }
  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), "in method '" "FIX::operator >" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap___eq____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator ==" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator ==" "', argument " "2"" of type '" "char const *""'");
  }
  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 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  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), "in method '" "FIX::operator ==" "', argument " "1"" of type '" "char const *""'");
  }
  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), "in method '" "FIX::operator ==" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap___le____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator <=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator <=" "', argument " "2"" of type '" "char const *""'");
  }
  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 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  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), "in method '" "FIX::operator <=" "', argument " "1"" of type '" "char const *""'");
  }
  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), "in method '" "FIX::operator <=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap___ge____SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator >=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator >=" "', argument " "2"" of type '" "char const *""'");
  }
  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 ;
  bool result;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  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), "in method '" "FIX::operator >=" "', argument " "1"" of type '" "char const *""'");
  }
  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), "in method '" "FIX::operator >=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap___lt____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator <" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  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), "in method '" "FIX::operator <" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator <" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator <" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator >" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  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), "in method '" "FIX::operator >" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator >" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator >" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded '__gt__'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap___eq____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator ==" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  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), "in method '" "FIX::operator ==" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator ==" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator ==" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator <=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  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), "in method '" "FIX::operator <=" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <=" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator <=" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <=" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator <=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded '__le__'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap___ge____SWIG_2(int argc, VALUE *argv, VALUE self) {
  FIX::StringField *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator >=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >=" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  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), "in method '" "FIX::operator >=" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >=" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator >=" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >=" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__StringField,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::operator >=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >=" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded '__ge__'");
  return Qnil;
}


swig_class cCharField;

SWIGINTERN VALUE
_wrap_new_CharField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char arg2 ;
  FIX::CharField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CharField";
  
  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), "in method '" "FIX::CharField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::CharField" "', argument " "2"" of type '" "char""'");
  } 
  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 ;
  FIX::CharField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CharField";
  
  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), "in method '" "FIX::CharField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CharField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::CharField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CharField * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setValue" "', argument " "2"" of type '" "char""'");
  } 
  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 ;
  char result;
  void *argp1 = 0 ;
  int res1 = 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__CharField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::CharField const *""'"); 
  }
  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 cDoubleField;

SWIGINTERN VALUE
_wrap_new_DoubleField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  double arg2 ;
  int arg3 ;
  FIX::DoubleField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DoubleField";
  
  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), "in method '" "FIX::DoubleField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::DoubleField" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FIX::DoubleField" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  FIX::DoubleField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DoubleField";
  
  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), "in method '" "FIX::DoubleField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::DoubleField" "', argument " "2"" of type '" "double""'");
  } 
  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 ;
  FIX::DoubleField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DoubleField";
  
  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), "in method '" "FIX::DoubleField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DoubleField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::DoubleField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setValue" "', argument " "3"" of type '" "int""'");
  } 
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::DoubleField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setValue" "', argument " "2"" of type '" "double""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'DoubleField_setValue'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DoubleField_getValue(int argc, VALUE *argv, VALUE self) {
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  double result;
  void *argp1 = 0 ;
  int res1 = 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__DoubleField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::DoubleField const *""'"); 
  }
  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 cIntField;

SWIGINTERN VALUE
_wrap_new_IntField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  FIX::IntField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IntField";
  
  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), "in method '" "FIX::IntField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::IntField" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  FIX::IntField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IntField";
  
  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), "in method '" "FIX::IntField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IntField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::IntField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IntField * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setValue" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__IntField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::IntField const *""'"); 
  }
  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 cBoolField;

SWIGINTERN VALUE
_wrap_new_BoolField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  bool arg2 ;
  FIX::BoolField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BoolField";
  
  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), "in method '" "FIX::BoolField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::BoolField" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  FIX::BoolField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BoolField";
  
  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), "in method '" "FIX::BoolField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BoolField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::BoolField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BoolField * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setValue" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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__BoolField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::BoolField const *""'"); 
  }
  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 cUtcTimeStampField;

SWIGINTERN VALUE
_wrap_new_UtcTimeStampField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcTimeStamp *arg2 = 0 ;
  bool arg3 ;
  FIX::UtcTimeStampField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  
  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), "in method '" "FIX::UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FIX::UtcTimeStampField" "', argument " "3"" of type '" "bool""'");
  } 
  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 ;
  FIX::UtcTimeStampField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  
  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), "in method '" "FIX::UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  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 ;
  FIX::UtcTimeStampField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  
  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), "in method '" "FIX::UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::UtcTimeStampField" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  FIX::UtcTimeStampField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeStampField";
  
  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), "in method '" "FIX::UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UtcTimeStampField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::UtcTimeStampField *""'"); 
  }
  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), "in method '" "setValue" "', argument " "2"" of type '" "UtcTimeStamp &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setValue" "', argument " "2"" of type '" "UtcTimeStamp &""'"); 
  }
  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 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 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__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::UtcTimeStampField const *""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap_UtcTimeStampField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator <" "', argument " "1"" of type '" "FIX::UtcTimeStampField const *""'"); 
  }
  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), "in method '" "operator <" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator <" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  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 VALUE
_wrap_UtcTimeStampField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator ==" "', argument " "1"" of type '" "FIX::UtcTimeStampField const *""'"); 
  }
  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), "in method '" "operator ==" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator ==" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  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 cUtcDateField;

SWIGINTERN VALUE
_wrap_new_UtcDateField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcDate *arg2 = 0 ;
  FIX::UtcDateField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcDateField";
  
  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), "in method '" "FIX::UtcDateField" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::UtcDateField" "', argument " "2"" of type '" "UtcDate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UtcDateField" "', argument " "2"" of type '" "UtcDate const &""'"); 
  }
  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 ;
  FIX::UtcDateField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcDateField";
  
  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), "in method '" "FIX::UtcDateField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UtcDateField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::UtcDateField *""'"); 
  }
  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), "in method '" "setValue" "', argument " "2"" of type '" "UtcDate &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setValue" "', argument " "2"" of type '" "UtcDate &""'"); 
  }
  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 ;
  UtcDate result;
  void *argp1 = 0 ;
  int res1 = 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__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::UtcDateField const *""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap_UtcDateField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator <" "', argument " "1"" of type '" "FIX::UtcDateField const *""'"); 
  }
  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), "in method '" "operator <" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator <" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  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 VALUE
_wrap_UtcDateField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator ==" "', argument " "1"" of type '" "FIX::UtcDateField const *""'"); 
  }
  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), "in method '" "operator ==" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator ==" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  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 cUtcTimeOnlyField;

SWIGINTERN VALUE
_wrap_new_UtcTimeOnlyField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  UtcTimeOnly *arg2 = 0 ;
  bool arg3 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  
  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), "in method '" "FIX::UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeOnly * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FIX::UtcTimeOnlyField" "', argument " "3"" of type '" "bool""'");
  } 
  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 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  
  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), "in method '" "FIX::UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  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), "in method '" "FIX::UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  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 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  
  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), "in method '" "FIX::UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::UtcTimeOnlyField" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UtcTimeOnlyField";
  
  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), "in method '" "FIX::UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UtcTimeOnlyField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField *""'"); 
  }
  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), "in method '" "setValue" "', argument " "2"" of type '" "UtcTimeOnly &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setValue" "', argument " "2"" of type '" "UtcTimeOnly &""'"); 
  }
  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 ;
  UtcTimeOnly result;
  void *argp1 = 0 ;
  int res1 = 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__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField const *""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap_UtcTimeOnlyField___lt__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator <" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField const *""'"); 
  }
  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), "in method '" "operator <" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator <" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  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 VALUE
_wrap_UtcTimeOnlyField___eq__(int argc, VALUE *argv, VALUE self) {
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "operator ==" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField const *""'"); 
  }
  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), "in method '" "operator ==" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "operator ==" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  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 cCheckSumField;

SWIGINTERN VALUE
_wrap_new_CheckSumField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  FIX::CheckSumField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CheckSumField";
  
  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), "in method '" "FIX::CheckSumField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::CheckSumField" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  FIX::CheckSumField *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CheckSumField";
  
  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), "in method '" "FIX::CheckSumField" "', argument " "1"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CheckSumField'");
  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), "in method '" "setValue" "', argument " "1"" of type '" "FIX::CheckSumField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CheckSumField * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setValue" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__CheckSumField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getValue" "', argument " "1"" of type '" "FIX::CheckSumField const *""'"); 
  }
  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 cFieldMap;

SWIGINTERN VALUE
_wrap_new_FieldMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
  message_order *arg1 = 0 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  
  if ((argc < 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), "in method '" "FIX::FieldMap" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FieldMap" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  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) {
  FIX::FieldMap *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  
  if ((argc < 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), "in method '" "FIX::FieldMap" "', argument " "1"" of type '" "int const []""'"); 
  } 
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FieldMap";
  
  if ((argc < 1) || (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), "in method '" "FIX::FieldMap" "', argument " "1"" of type '" "FIX::FieldMap const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FieldMap" "', argument " "1"" of type '" "FIX::FieldMap const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FieldMap'");
  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), "in method '" "setField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  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), "in method '" "setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setField" "', argument " "3"" of type '" "bool""'");
  } 
  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), "in method '" "setField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  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), "in method '" "setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  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), "in method '" "setField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setField" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setField" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_setField'");
  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 ;
  FIX::FieldBase *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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), "in method '" "getField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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), "in method '" "getField" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getField" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  try {
    {
      FIX::FieldBase &_result_ref = ((FIX::FieldMap const *)arg1)->getField(*arg2);
      result = (FIX::FieldBase *) &_result_ref;
    }
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "getField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      std::string const &_result_ref = ((FIX::FieldMap const *)arg1)->getField(arg2);
      result = (std::string *) &_result_ref;
    }
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_getField'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_getFieldRef(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  FIX::FieldBase *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "getFieldRef" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getFieldRef" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      FIX::FieldBase const &_result_ref = ((FIX::FieldMap const *)arg1)->getFieldRef(arg2);
      result = (FIX::FieldBase *) &_result_ref;
    }
  }
  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 ;
  FIX::FieldBase *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "getFieldPtr" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getFieldPtr" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "isSetField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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), "in method '" "isSetField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isSetField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "isSetField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isSetField" "', argument " "2"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_isSetField'");
  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), "in method '" "removeField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "removeField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addGroup" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "addGroup" "', argument " "4"" of type '" "bool""'");
  } 
  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), "in method '" "addGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addGroup" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_addGroup'");
  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), "in method '" "replaceGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "replaceGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "replaceGroup" "', argument " "3"" of type '" "int""'");
  } 
  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), "in method '" "replaceGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "replaceGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  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), "in method '" "getGroup" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getGroup" "', argument " "3"" of type '" "int""'");
  } 
  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), "in method '" "getGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  arg4 = reinterpret_cast< FIX::FieldMap * >(argp4);
  try {
    {
      FIX::FieldMap &_result_ref = ((FIX::FieldMap const *)arg1)->getGroup(arg2,arg3,*arg4);
      result = (FIX::FieldMap *) &_result_ref;
    }
  }
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getGroupRef" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getGroupRef" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getGroupRef" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  try {
    {
      FIX::FieldMap &_result_ref = ((FIX::FieldMap const *)arg1)->getGroupRef(arg2,arg3);
      result = (FIX::FieldMap *) &_result_ref;
    }
  }
  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 ;
  FIX::FieldMap *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getGroupPtr" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getGroupPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getGroupPtr" "', argument " "3"" of type '" "int""'");
  } 
  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), "in method '" "removeGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "removeGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "removeGroup" "', argument " "3"" of type '" "int""'");
  } 
  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), "in method '" "removeGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "removeGroup" "', argument " "2"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_removeGroup'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_hasGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "hasGroup" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hasGroup" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hasGroup" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hasGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "hasGroup" "', argument " "3"" of type '" "int""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_hasGroup'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_groupCount(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "groupCount" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "groupCount" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "clear" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isEmpty" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "totalFields" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calculateString" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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), "in method '" "calculateString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::string &_result_ref = ((FIX::FieldMap const *)arg1)->calculateString(*arg2,arg3);
    result = (std::string *) &_result_ref;
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  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), "in method '" "calculateString" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  {
    std::string &_result_ref = ((FIX::FieldMap const *)arg1)->calculateString(*arg2);
    result = (std::string *) &_result_ref;
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_calculateString'");
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "calculateLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "calculateLength" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "calculateLength" "', argument " "4"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "calculateLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "calculateLength" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "calculateLength" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_calculateLength'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_calculateTotal__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "calculateTotal" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "calculateTotal" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calculateTotal" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FieldMap_calculateTotal'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FieldMap_begin(int argc, VALUE *argv, VALUE self) {
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldMap::iterator result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "begin" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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 ;
  FIX::FieldMap::iterator result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "end" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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 ;
  FIX::FieldMap::g_iterator result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "g_begin" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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 ;
  FIX::FieldMap::g_iterator result;
  void *argp1 = 0 ;
  int res1 = 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__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "g_end" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  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
headerOrder_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(FIX::headerOrder), SWIGTYPE_p_int,  0 );
  return _val;
}


swig_class cMessage;

SWIGINTERN VALUE
_wrap_new_Message__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  
  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 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  
  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), "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::Message" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  
  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), "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  
  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), "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FIX::Message" "', argument " "3"" of type '" "bool""'");
  } 
  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 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  
  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), "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  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 ;
  FIX::Message *result = 0 ;
  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";
  
  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), "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  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), "in method '" "FIX::Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FIX::Message" "', argument " "4"" of type '" "bool""'");
  } 
  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 ;
  FIX::Message *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  
  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), "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__DataDictionary,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  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), "in method '" "FIX::Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  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 ;
  FIX::Message *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Message";
  
  if ((argc < 1) || (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), "in method '" "FIX::Message" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Message'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_InitializeXML(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  bool result;
  int res1 = SWIG_OLDOBJ ;
  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), "in method '" "FIX::Message::InitializeXML" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::InitializeXML" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "addGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  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), "in method '" "replaceGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "replaceGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  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 ;
  Group *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getGroup" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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), "in method '" "getGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  try {
    {
      Group &_result_ref = ((FIX::Message const *)arg1)->getGroup(arg2,*arg3);
      result = (Group *) &_result_ref;
    }
  }
  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), "in method '" "removeGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "removeGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  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), "in method '" "removeGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_removeGroup'");
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "hasGroup" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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), "in method '" "hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hasGroup" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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), "in method '" "hasGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_hasGroup'");
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "toString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "toString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "toString" "', argument " "4"" of type '" "int""'");
  } 
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "toString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "toString" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "toString" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  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), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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), "in method '" "toString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "toString" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "toString" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4,arg5);
    result = (std::string *) &_result_ref;
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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), "in method '" "toString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "toString" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4);
    result = (std::string *) &_result_ref;
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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), "in method '" "toString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2,arg3);
    result = (std::string *) &_result_ref;
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  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), "in method '" "toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  {
    std::string &_result_ref = ((FIX::Message const *)arg1)->toString(*arg2);
    result = (std::string *) &_result_ref;
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_toString'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_toXML__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "toXML" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  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), "in method '" "toXML" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  {
    std::string &_result_ref = ((FIX::Message const *)arg1)->toXML(*arg2);
    result = (std::string *) &_result_ref;
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_toXML'");
  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), "in method '" "reverseRoute" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "reverseRoute" "', argument " "2"" of type '" "FIX::Header const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "reverseRoute" "', argument " "2"" of type '" "FIX::Header const &""'"); 
  }
  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), "in method '" "setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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_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), "in method '" "setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setString((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_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), "in method '" "setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setString" "', argument " "3"" of type '" "bool""'");
  } 
  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), "in method '" "setString" "', argument " "4"" of type '" "FIX::DataDictionary const *""'"); 
  }
  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), "in method '" "setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setString" "', argument " "3"" of type '" "bool""'");
  } 
  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), "in method '" "setString" "', argument " "4"" of type '" "FIX::DataDictionary const *""'"); 
  }
  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), "in method '" "setString" "', argument " "5"" of type '" "FIX::DataDictionary const *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_setString'");
  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), "in method '" "setGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "setGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setGroup" "', argument " "3"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setGroup" "', argument " "3"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldBase * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "setGroup" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setGroup" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "setGroup" "', argument " "5"" of type '" "std::string::size_type &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setGroup" "', argument " "5"" of type '" "std::string::size_type &""'"); 
  }
  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), "in method '" "setGroup" "', argument " "6"" of type '" "FIX::FieldMap &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setGroup" "', argument " "6"" of type '" "FIX::FieldMap &""'"); 
  }
  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), "in method '" "setGroup" "', argument " "7"" of type '" "DataDictionary const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setGroup" "', argument " "7"" of type '" "DataDictionary const &""'"); 
  }
  arg7 = reinterpret_cast< DataDictionary * >(argp7);
  (arg1)->setGroup((std::string const &)*arg2,(FIX::FieldBase const &)*arg3,(std::string const &)*arg4,*arg5,*arg6,(DataDictionary const &)*arg7);
  {
    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 ;
  bool result;
  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), "in method '" "setStringHeader" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "setStringHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setStringHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::Header *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getHeader" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    FIX::Header const &_result_ref = ((FIX::Message const *)arg1)->getHeader();
    result = (FIX::Header *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 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 ;
  FIX::Header *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getHeader" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    FIX::Header &_result_ref = (arg1)->getHeader();
    result = (FIX::Header *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_getHeader'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_getTrailer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Header *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getTrailer" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    FIX::Header const &_result_ref = ((FIX::Message const *)arg1)->getTrailer();
    result = (FIX::Header *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 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 ;
  FIX::Trailer *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getTrailer" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    FIX::Trailer &_result_ref = (arg1)->getTrailer();
    result = (FIX::Trailer *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_getTrailer'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_hasValidStructure(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  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), "in method '" "hasValidStructure" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int 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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bodyLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bodyLength" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bodyLength" "', argument " "4"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  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__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bodyLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bodyLength" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bodyLength" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_bodyLength'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_checkSum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int arg2 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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), "in method '" "checkSum" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "checkSum" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "checkSum" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_checkSum'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isAdmin(int argc, VALUE *argv, VALUE self) {
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isAdmin" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isApp" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isEmpty" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "clear" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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 ;
  bool result;
  void *argp1 ;
  int res1 = 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_MsgType,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Message::isAdminMsgType" "', argument " "1"" of type '" "MsgType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::isAdminMsgType" "', argument " "1"" of type '" "MsgType const &""'"); 
  }
  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 ;
  ApplVerID result;
  void *argp1 ;
  int res1 = 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_BeginString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Message::toApplVerID" "', argument " "1"" of type '" "BeginString const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::toApplVerID" "', argument " "1"" of type '" "BeginString const &""'"); 
  }
  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 ;
  BeginString result;
  void *argp1 ;
  int res1 = 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_ApplVerID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Message::toBeginString" "', argument " "1"" of type '" "ApplVerID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::toBeginString" "', argument " "1"" of type '" "ApplVerID const &""'"); 
  }
  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 ;
  bool result;
  int val1 ;
  int ecode1 = 0 ;
  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), "in method '" "FIX::Message::isHeaderField" "', argument " "1"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Message::isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  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), "in method '" "FIX::Message::isHeaderField" "', argument " "2"" of type '" "DataDictionary const *""'"); 
  }
  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 ;
  bool result;
  void *argp1 ;
  int res1 = 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__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Message::isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_isHeaderField'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Message_isTrailerField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  bool result;
  int val1 ;
  int ecode1 = 0 ;
  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), "in method '" "FIX::Message::isTrailerField" "', argument " "1"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Message::isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  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), "in method '" "FIX::Message::isTrailerField" "', argument " "2"" of type '" "DataDictionary const *""'"); 
  }
  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 ;
  bool result;
  void *argp1 ;
  int res1 = 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__FieldBase,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Message::isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Message::isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_isTrailerField'");
  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 ;
  SessionID result;
  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), "in method '" "getSessionID" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getSessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  SessionID result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSessionID" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Message_getSessionID'");
  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), "in method '" "setSessionID" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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), "in method '" "setSessionID" "', argument " "2"" of type '" "SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setSessionID" "', argument " "2"" of type '" "SessionID const &""'"); 
  }
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "__str__" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  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;
}

SWIGINTERN VALUE
_wrap___lshift____SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::Message *arg2 = 0 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  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), "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  {
    std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::Message const &)*arg2);
    result = (std::ostream *) &_result_ref;
  }
  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 ;
  MsgType result;
  int res1 = SWIG_OLDOBJ ;
  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), "in method '" "FIX::identifyType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::identifyType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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 cGroup;

SWIGINTERN VALUE
_wrap_new_Group__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  FIX::Group *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  
  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), "in method '" "FIX::Group" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::Group" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  FIX::Group *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  
  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), "in method '" "FIX::Group" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::Group" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "FIX::Group" "', argument " "3"" of type '" "int const []""'"); 
  } 
  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 ;
  FIX::Group *result = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  
  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), "in method '" "FIX::Group" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::Group" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "FIX::Group" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Group" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  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 ;
  FIX::Group *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Group";
  
  if ((argc < 1) || (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), "in method '" "FIX::Group" "', argument " "1"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Group" "', argument " "1"" of type '" "FIX::Group const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Group'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Group_field(int argc, VALUE *argv, VALUE self) {
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "field" "', argument " "1"" of type '" "FIX::Group const *""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delim" "', argument " "1"" of type '" "FIX::Group const *""'"); 
  }
  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), "in method '" "addGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  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), "in method '" "addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  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), "in method '" "replaceGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  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), "in method '" "replaceGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  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 ;
  FIX::Group *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  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__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getGroup" "', argument " "1"" of type '" "FIX::Group const *""'"); 
  }
  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), "in method '" "getGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  try {
    {
      FIX::Group &_result_ref = ((FIX::Group const *)arg1)->getGroup(arg2,*arg3);
      result = (FIX::Group *) &_result_ref;
    }
  }
  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), "in method '" "removeGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  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), "in method '" "removeGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  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), "in method '" "removeGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  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), "in method '" "removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Group_removeGroup'");
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hasGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  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), "in method '" "hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  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__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hasGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  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), "in method '" "hasGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  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), "in method '" "hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Group_hasGroup'");
  return Qnil;
}


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

swig_class cRelatedPartyID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartyID(FIX::RelatedPartyID *arg1) {
    delete arg1;
}

swig_class cMaxPriceLevels;

SWIGINTERN VALUE
_wrap_new_MaxPriceLevels__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaxPriceLevels *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceLevels";
  
  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 ;
  FIX::MaxPriceLevels *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceLevels";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MaxPriceLevels" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaxPriceLevels" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaxPriceLevels'");
  return Qnil;
}


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

swig_class cDerivativeEncodedIssuer;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEncodedIssuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuer";
  
  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 ;
  FIX::DerivativeEncodedIssuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuer";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeEncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEncodedIssuer'");
  return Qnil;
}


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

swig_class cNoCompIDs;

SWIGINTERN VALUE
_wrap_new_NoCompIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoCompIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCompIDs";
  
  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 ;
  FIX::NoCompIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCompIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoCompIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoCompIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoCompIDs'");
  return Qnil;
}


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

swig_class cSettlInstRefID;

SWIGINTERN VALUE
_wrap_new_SettlInstRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstRefID";
  
  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 ;
  FIX::SettlInstRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlInstRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstRefID'");
  return Qnil;
}


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

swig_class cNestedPartyID;

SWIGINTERN VALUE
_wrap_new_NestedPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NestedPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyID";
  
  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 ;
  FIX::NestedPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NestedPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NestedPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NestedPartyID'");
  return Qnil;
}


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

swig_class cDetachmentPoint;

SWIGINTERN VALUE
_wrap_new_DetachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DetachmentPoint *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DetachmentPoint";
  
  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 ;
  FIX::DetachmentPoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DetachmentPoint";
  
  if ((argc < 1) || (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), "in method '" "FIX::DetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DetachmentPoint'");
  return Qnil;
}


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

swig_class cLateIndicator;

SWIGINTERN VALUE
_wrap_new_LateIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LateIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LateIndicator";
  
  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 ;
  FIX::LateIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LateIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::LateIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LateIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LateIndicator'");
  return Qnil;
}


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

swig_class cRiskEncodedSecurityDesc;

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


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

SWIGINTERN VALUE
_wrap_new_RiskEncodedSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  FIX::RiskEncodedSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskEncodedSecurityDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::RiskEncodedSecurityDesc *)new FIX::RiskEncodedSecurityDesc((FIX::DATA const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskEncodedSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskEncodedSecurityDesc__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_RiskEncodedSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskEncodedSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskEncodedSecurityDesc(FIX::RiskEncodedSecurityDesc *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecuritySubType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecuritySubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecuritySubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecuritySubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecuritySubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecuritySubType(FIX::RelationshipRiskSecuritySubType *arg1) {
    delete arg1;
}

swig_class cSecurityListID;

SWIGINTERN VALUE
_wrap_new_SecurityListID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityListID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListID";
  
  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 ;
  FIX::SecurityListID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityListID'");
  return Qnil;
}


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

swig_class cDerivativeFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_DerivativeFlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeFlowScheduleType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFlowScheduleType";
  
  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 ;
  FIX::DerivativeFlowScheduleType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFlowScheduleType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeFlowScheduleType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeFlowScheduleType(FIX::DerivativeFlowScheduleType *arg1) {
    delete arg1;
}

swig_class cEncodedSymbolLen;

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


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

SWIGINTERN VALUE
_wrap_new_EncodedSymbolLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  FIX::EncodedSymbolLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSymbolLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSymbolLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSymbolLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::EncodedSymbolLen *)new FIX::EncodedSymbolLen((FIX::LENGTH const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSymbolLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSymbolLen__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_EncodedSymbolLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSymbolLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSymbolLen(FIX::EncodedSymbolLen *arg1) {
    delete arg1;
}

swig_class cFlexibleIndicator;

SWIGINTERN VALUE
_wrap_new_FlexibleIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FlexibleIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlexibleIndicator";
  
  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 ;
  FIX::FlexibleIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlexibleIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::FlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FlexibleIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FlexibleIndicator(FIX::FlexibleIndicator *arg1) {
    delete arg1;
}

swig_class cNoExecInstRules;

SWIGINTERN VALUE
_wrap_new_NoExecInstRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoExecInstRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExecInstRules";
  
  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 ;
  FIX::NoExecInstRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExecInstRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoExecInstRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoExecInstRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoExecInstRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoExecInstRules(FIX::NoExecInstRules *arg1) {
    delete arg1;
}

swig_class cSideTrdRegTimestamp;

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestamp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideTrdRegTimestamp *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  
  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 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  
  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), "in method '" "FIX::SideTrdRegTimestamp" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  
  if ((argc < 1) || (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), "in method '" "FIX::SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestamp";
  
  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), "in method '" "FIX::SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::SideTrdRegTimestamp" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideTrdRegTimestamp'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdRegTimestamp(FIX::SideTrdRegTimestamp *arg1) {
    delete arg1;
}

swig_class cDeliveryForm;

SWIGINTERN VALUE
_wrap_new_DeliveryForm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeliveryForm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryForm";
  
  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 ;
  FIX::DeliveryForm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryForm";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeliveryForm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeliveryForm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeliveryForm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliveryForm(FIX::DeliveryForm *arg1) {
    delete arg1;
}

swig_class cExecRestatementReason;

SWIGINTERN VALUE
_wrap_new_ExecRestatementReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecRestatementReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecRestatementReason";
  
  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 ;
  FIX::ExecRestatementReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecRestatementReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExecRestatementReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecRestatementReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecRestatementReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecRestatementReason(FIX::ExecRestatementReason *arg1) {
    delete arg1;
}

swig_class cMidYield;

SWIGINTERN VALUE
_wrap_new_MidYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MidYield *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MidYield";
  
  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 ;
  FIX::MidYield *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MidYield";
  
  if ((argc < 1) || (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), "in method '" "FIX::MidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MidYield'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MidYield(FIX::MidYield *arg1) {
    delete arg1;
}

swig_class cContractMultiplier;

SWIGINTERN VALUE
_wrap_new_ContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContractMultiplier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplier";
  
  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 ;
  FIX::ContractMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContractMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContractMultiplier(FIX::ContractMultiplier *arg1) {
    delete arg1;
}

swig_class cPartyAltIDSource;

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


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

SWIGINTERN VALUE
_wrap_new_PartyAltIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  FIX::PartyAltIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyAltIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::PartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::PartyAltIDSource *)new FIX::PartyAltIDSource((FIX::CHAR const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PartyAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyAltIDSource__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_PartyAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyAltIDSource(FIX::PartyAltIDSource *arg1) {
    delete arg1;
}

swig_class cCcyAmt;

SWIGINTERN VALUE
_wrap_new_CcyAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CcyAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CcyAmt";
  
  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 ;
  FIX::CcyAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CcyAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::CcyAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CcyAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CcyAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CcyAmt(FIX::CcyAmt *arg1) {
    delete arg1;
}

swig_class cAllocIntermedReqType;

SWIGINTERN VALUE
_wrap_new_AllocIntermedReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocIntermedReqType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocIntermedReqType";
  
  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 ;
  FIX::AllocIntermedReqType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocIntermedReqType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocIntermedReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocIntermedReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocIntermedReqType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocIntermedReqType(FIX::AllocIntermedReqType *arg1) {
    delete arg1;
}

swig_class cNoNested2PartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNested2PartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNested2PartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartyIDs";
  
  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 ;
  FIX::NoNested2PartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNested2PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNested2PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNested2PartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested2PartyIDs(FIX::NoNested2PartyIDs *arg1) {
    delete arg1;
}

swig_class cUnderlyingIssuer;

SWIGINTERN VALUE
_wrap_new_UnderlyingIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingIssuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssuer";
  
  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 ;
  FIX::UnderlyingIssuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssuer";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingIssuer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingIssuer(FIX::UnderlyingIssuer *arg1) {
    delete arg1;
}

swig_class cLegOrderQty;

SWIGINTERN VALUE
_wrap_new_LegOrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegOrderQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOrderQty";
  
  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 ;
  FIX::LegOrderQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOrderQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegOrderQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOrderQty(FIX::LegOrderQty *arg1) {
    delete arg1;
}

swig_class cMinTradeVol;

SWIGINTERN VALUE
_wrap_new_MinTradeVol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MinTradeVol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinTradeVol";
  
  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 ;
  FIX::MinTradeVol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinTradeVol";
  
  if ((argc < 1) || (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), "in method '" "FIX::MinTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MinTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MinTradeVol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MinTradeVol(FIX::MinTradeVol *arg1) {
    delete arg1;
}

swig_class cSettlCurrAmt;

SWIGINTERN VALUE
_wrap_new_SettlCurrAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlCurrAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrAmt";
  
  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 ;
  FIX::SettlCurrAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlCurrAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrAmt(FIX::SettlCurrAmt *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrumentPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyRole";
  
  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 ;
  FIX::DerivativeInstrumentPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrumentPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartyRole(FIX::DerivativeInstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class cYieldRedemptionPriceType;

SWIGINTERN VALUE
_wrap_new_YieldRedemptionPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::YieldRedemptionPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPriceType";
  
  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 ;
  FIX::YieldRedemptionPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::YieldRedemptionPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::YieldRedemptionPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_YieldRedemptionPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldRedemptionPriceType(FIX::YieldRedemptionPriceType *arg1) {
    delete arg1;
}

swig_class cNewsRefID;

SWIGINTERN VALUE
_wrap_new_NewsRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NewsRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsRefID";
  
  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 ;
  FIX::NewsRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NewsRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NewsRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NewsRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsRefID(FIX::NewsRefID *arg1) {
    delete arg1;
}

swig_class cSecurityListTypeSource;

SWIGINTERN VALUE
_wrap_new_SecurityListTypeSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityListTypeSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListTypeSource";
  
  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 ;
  FIX::SecurityListTypeSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListTypeSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityListTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityListTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityListTypeSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListTypeSource(FIX::SecurityListTypeSource *arg1) {
    delete arg1;
}

swig_class cApplReqID;

SWIGINTERN VALUE
_wrap_new_ApplReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReqID";
  
  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 ;
  FIX::ApplReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReqID(FIX::ApplReqID *arg1) {
    delete arg1;
}

swig_class cDerivativeFuturesValuationMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeFuturesValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeFuturesValuationMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFuturesValuationMethod";
  
  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 ;
  FIX::DerivativeFuturesValuationMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFuturesValuationMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeFuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeFuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeFuturesValuationMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeFuturesValuationMethod(FIX::DerivativeFuturesValuationMethod *arg1) {
    delete arg1;
}

swig_class cNoLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoLegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoLegSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegSecurityAltID";
  
  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::STRING *arg1 = 0 ;
  FIX::NoLegSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegSecurityAltID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NoLegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoLegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  result = (FIX::NoLegSecurityAltID *)new FIX::NoLegSecurityAltID((FIX::STRING 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__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoLegSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegSecurityAltID(FIX::NoLegSecurityAltID *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityType;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityType";
  
  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 ;
  FIX::DerivativeSecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityType(FIX::DerivativeSecurityType *arg1) {
    delete arg1;
}

swig_class cCollInquiryQualifier;

SWIGINTERN VALUE
_wrap_new_CollInquiryQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollInquiryQualifier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryQualifier";
  
  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 ;
  FIX::CollInquiryQualifier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryQualifier";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollInquiryQualifier" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollInquiryQualifier" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollInquiryQualifier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryQualifier(FIX::CollInquiryQualifier *arg1) {
    delete arg1;
}

swig_class cRawData;

SWIGINTERN VALUE
_wrap_new_RawData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RawData *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RawData";
  
  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 ;
  FIX::RawData *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RawData";
  
  if ((argc < 1) || (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), "in method '" "FIX::RawData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RawData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RawData'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RawData(FIX::RawData *arg1) {
    delete arg1;
}

swig_class cCashSettlAgentContactPhone;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentContactPhone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashSettlAgentContactPhone *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactPhone";
  
  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 ;
  FIX::CashSettlAgentContactPhone *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactPhone";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashSettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashSettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashSettlAgentContactPhone'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentContactPhone(FIX::CashSettlAgentContactPhone *arg1) {
    delete arg1;
}

swig_class cCreditRating;

SWIGINTERN VALUE
_wrap_new_CreditRating__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CreditRating *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CreditRating";
  
  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 ;
  FIX::CreditRating *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CreditRating";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CreditRating'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CreditRating(FIX::CreditRating *arg1) {
    delete arg1;
}

swig_class cContingencyType;

SWIGINTERN VALUE
_wrap_new_ContingencyType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContingencyType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContingencyType";
  
  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 ;
  FIX::ContingencyType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContingencyType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ContingencyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContingencyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContingencyType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContingencyType(FIX::ContingencyType *arg1) {
    delete arg1;
}

swig_class cStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_StrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikeCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeCurrency";
  
  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 ;
  FIX::StrikeCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::StrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikeCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeCurrency(FIX::StrikeCurrency *arg1) {
    delete arg1;
}

swig_class cTradeVolume;

SWIGINTERN VALUE
_wrap_new_TradeVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeVolume *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeVolume";
  
  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 ;
  FIX::TradeVolume *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeVolume";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradeVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeVolume'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeVolume(FIX::TradeVolume *arg1) {
    delete arg1;
}

swig_class cSideTrdRegTimestampSrc;

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestampSrc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideTrdRegTimestampSrc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampSrc";
  
  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 ;
  FIX::SideTrdRegTimestampSrc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampSrc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideTrdRegTimestampSrc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTrdRegTimestampSrc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideTrdRegTimestampSrc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdRegTimestampSrc(FIX::SideTrdRegTimestampSrc *arg1) {
    delete arg1;
}

swig_class cDeliveryDate;

SWIGINTERN VALUE
_wrap_new_DeliveryDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeliveryDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryDate";
  
  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 ;
  FIX::DeliveryDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::DeliveryDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeliveryDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeliveryDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliveryDate(FIX::DeliveryDate *arg1) {
    delete arg1;
}

swig_class cEmailType;

SWIGINTERN VALUE
_wrap_new_EmailType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EmailType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EmailType";
  
  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 ;
  FIX::EmailType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EmailType";
  
  if ((argc < 1) || (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), "in method '" "FIX::EmailType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EmailType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EmailType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EmailType(FIX::EmailType *arg1) {
    delete arg1;
}

swig_class cEncodedListExecInst;

SWIGINTERN VALUE
_wrap_new_EncodedListExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedListExecInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInst";
  
  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 ;
  FIX::EncodedListExecInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedListExecInst" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedListExecInst" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedListExecInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListExecInst(FIX::EncodedListExecInst *arg1) {
    delete arg1;
}

swig_class cContraTradeTime;

SWIGINTERN VALUE
_wrap_new_ContraTradeTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContraTradeTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  
  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 ;
  FIX::ContraTradeTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  
  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), "in method '" "FIX::ContraTradeTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::ContraTradeTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::ContraTradeTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeTime";
  
  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), "in method '" "FIX::ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ContraTradeTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContraTradeTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraTradeTime(FIX::ContraTradeTime *arg1) {
    delete arg1;
}

swig_class cMaturityMonthYearIncrement;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityMonthYearIncrement *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrement";
  
  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 ;
  FIX::MaturityMonthYearIncrement *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrement";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MaturityMonthYearIncrement" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityMonthYearIncrement" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityMonthYearIncrement'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYearIncrement(FIX::MaturityMonthYearIncrement *arg1) {
    delete arg1;
}

swig_class cRootPartyIDSource;

SWIGINTERN VALUE
_wrap_new_RootPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RootPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyIDSource";
  
  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 ;
  FIX::RootPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::RootPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RootPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RootPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartyIDSource(FIX::RootPartyIDSource *arg1) {
    delete arg1;
}

swig_class cUnderlyingCouponPaymentDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingCouponPaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCouponPaymentDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponPaymentDate";
  
  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 ;
  FIX::UnderlyingCouponPaymentDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponPaymentDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCouponPaymentDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCouponPaymentDate(FIX::UnderlyingCouponPaymentDate *arg1) {
    delete arg1;
}

swig_class cBidYield;

SWIGINTERN VALUE
_wrap_new_BidYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidYield *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidYield";
  
  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 ;
  FIX::BidYield *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidYield";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidYield'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidYield(FIX::BidYield *arg1) {
    delete arg1;
}

swig_class cIOIQltyInd;

SWIGINTERN VALUE
_wrap_new_IOIQltyInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIQltyInd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQltyInd";
  
  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 ;
  FIX::IOIQltyInd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQltyInd";
  
  if ((argc < 1) || (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), "in method '" "FIX::IOIQltyInd" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIQltyInd" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIQltyInd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIQltyInd(FIX::IOIQltyInd *arg1) {
    delete arg1;
}

swig_class cIssuer;

SWIGINTERN VALUE
_wrap_new_Issuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Issuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Issuer";
  
  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 ;
  FIX::Issuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Issuer";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Issuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Issuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Issuer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Issuer(FIX::Issuer *arg1) {
    delete arg1;
}

swig_class cCardNumber;

SWIGINTERN VALUE
_wrap_new_CardNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CardNumber *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardNumber";
  
  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 ;
  FIX::CardNumber *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardNumber";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CardNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CardNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CardNumber'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CardNumber(FIX::CardNumber *arg1) {
    delete arg1;
}

swig_class cNoRelatedPartyIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelatedPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelatedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelatedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelatedPartyIDs *)new FIX::NoRelatedPartyIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelatedPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelatedPartyIDs__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_NoRelatedPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelatedPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedPartyIDs(FIX::NoRelatedPartyIDs *arg1) {
    delete arg1;
}

swig_class cNoLegStipulations;

SWIGINTERN VALUE
_wrap_new_NoLegStipulations__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoLegStipulations *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegStipulations";
  
  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 ;
  FIX::NoLegStipulations *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegStipulations";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoLegStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoLegStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoLegStipulations'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegStipulations(FIX::NoLegStipulations *arg1) {
    delete arg1;
}

swig_class cLegSecurityExchange;

SWIGINTERN VALUE
_wrap_new_LegSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecurityExchange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityExchange";
  
  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 ;
  FIX::LegSecurityExchange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityExchange";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecurityExchange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityExchange(FIX::LegSecurityExchange *arg1) {
    delete arg1;
}

swig_class cCashOrderQty;

SWIGINTERN VALUE
_wrap_new_CashOrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashOrderQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashOrderQty";
  
  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 ;
  FIX::CashOrderQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashOrderQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::CashOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashOrderQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashOrderQty(FIX::CashOrderQty *arg1) {
    delete arg1;
}

swig_class cAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_AccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AccruedInterestAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestAmt";
  
  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 ;
  FIX::AccruedInterestAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::AccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AccruedInterestAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AccruedInterestAmt(FIX::AccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class cMDEntrySeller;

SWIGINTERN VALUE
_wrap_new_MDEntrySeller__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntrySeller *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySeller";
  
  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 ;
  FIX::MDEntrySeller *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySeller";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDEntrySeller" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntrySeller" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntrySeller'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntrySeller(FIX::MDEntrySeller *arg1) {
    delete arg1;
}

swig_class cLegPrice;

SWIGINTERN VALUE
_wrap_new_LegPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPrice";
  
  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 ;
  FIX::LegPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPrice(FIX::LegPrice *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskMaturityTime;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskMaturityTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::RelationshipRiskMaturityTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskMaturityTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  result = (FIX::RelationshipRiskMaturityTime *)new FIX::RelationshipRiskMaturityTime((FIX::TZTIMEONLY const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskMaturityTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskMaturityTime__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_RelationshipRiskMaturityTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskMaturityTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskMaturityTime(FIX::RelationshipRiskMaturityTime *arg1) {
    delete arg1;
}

swig_class cDeliverToCompID;

SWIGINTERN VALUE
_wrap_new_DeliverToCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeliverToCompID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToCompID";
  
  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 ;
  FIX::DeliverToCompID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToCompID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeliverToCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeliverToCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeliverToCompID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliverToCompID(FIX::DeliverToCompID *arg1) {
    delete arg1;
}

swig_class cTargetLocationID;

SWIGINTERN VALUE
_wrap_new_TargetLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetLocationID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetLocationID";
  
  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 ;
  FIX::TargetLocationID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetLocationID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TargetLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetLocationID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetLocationID(FIX::TargetLocationID *arg1) {
    delete arg1;
}

swig_class cOfferForwardPoints2;

SWIGINTERN VALUE
_wrap_new_OfferForwardPoints2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OfferForwardPoints2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints2";
  
  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 ;
  FIX::OfferForwardPoints2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints2";
  
  if ((argc < 1) || (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), "in method '" "FIX::OfferForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OfferForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OfferForwardPoints2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferForwardPoints2(FIX::OfferForwardPoints2 *arg1) {
    delete arg1;
}

swig_class cRatioQty;

SWIGINTERN VALUE
_wrap_new_RatioQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RatioQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RatioQty";
  
  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 ;
  FIX::RatioQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RatioQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::RatioQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RatioQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RatioQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RatioQty(FIX::RatioQty *arg1) {
    delete arg1;
}

swig_class cMultiLegRptTypeReq;

SWIGINTERN VALUE
_wrap_new_MultiLegRptTypeReq__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MultiLegRptTypeReq *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultiLegRptTypeReq";
  
  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 ;
  FIX::MultiLegRptTypeReq *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultiLegRptTypeReq";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MultiLegRptTypeReq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MultiLegRptTypeReq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MultiLegRptTypeReq'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MultiLegRptTypeReq(FIX::MultiLegRptTypeReq *arg1) {
    delete arg1;
}

swig_class cAllocAccount;

SWIGINTERN VALUE
_wrap_new_AllocAccount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocAccount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccount";
  
  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 ;
  FIX::AllocAccount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccount";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocAccount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAccount(FIX::AllocAccount *arg1) {
    delete arg1;
}

swig_class cTotalVolumeTraded;

SWIGINTERN VALUE
_wrap_new_TotalVolumeTraded__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalVolumeTraded *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTraded";
  
  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 ;
  FIX::TotalVolumeTraded *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTraded";
  
  if ((argc < 1) || (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), "in method '" "FIX::TotalVolumeTraded" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalVolumeTraded" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalVolumeTraded'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalVolumeTraded(FIX::TotalVolumeTraded *arg1) {
    delete arg1;
}

swig_class cLinesOfText;

SWIGINTERN VALUE
_wrap_new_LinesOfText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LinesOfText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LinesOfText";
  
  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 ;
  FIX::LinesOfText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LinesOfText";
  
  if ((argc < 1) || (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), "in method '" "FIX::LinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LinesOfText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LinesOfText(FIX::LinesOfText *arg1) {
    delete arg1;
}

swig_class cAccountType;

SWIGINTERN VALUE
_wrap_new_AccountType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AccountType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccountType";
  
  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 ;
  FIX::AccountType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccountType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AccountType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AccountType(FIX::AccountType *arg1) {
    delete arg1;
}

swig_class cMDEntryPositionNo;

SWIGINTERN VALUE
_wrap_new_MDEntryPositionNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryPositionNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPositionNo";
  
  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 ;
  FIX::MDEntryPositionNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPositionNo";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDEntryPositionNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryPositionNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryPositionNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryPositionNo(FIX::MDEntryPositionNo *arg1) {
    delete arg1;
}

swig_class cHaltReasonInt;

SWIGINTERN VALUE
_wrap_new_HaltReasonInt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HaltReasonInt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonInt";
  
  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 ;
  FIX::HaltReasonInt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonInt";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::HaltReasonInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HaltReasonInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HaltReasonInt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HaltReasonInt(FIX::HaltReasonInt *arg1) {
    delete arg1;
}

swig_class cFutSettDate;

SWIGINTERN VALUE
_wrap_new_FutSettDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FutSettDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate";
  
  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 ;
  FIX::FutSettDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::FutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FutSettDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FutSettDate(FIX::FutSettDate *arg1) {
    delete arg1;
}

swig_class cSecurityDesc;

SWIGINTERN VALUE
_wrap_new_SecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityDesc";
  
  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 ;
  FIX::SecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityDesc(FIX::SecurityDesc *arg1) {
    delete arg1;
}

swig_class cMinQty;

SWIGINTERN VALUE
_wrap_new_MinQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MinQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinQty";
  
  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 ;
  FIX::MinQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::MinQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MinQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MinQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MinQty(FIX::MinQty *arg1) {
    delete arg1;
}

swig_class cSettlCurrency;

SWIGINTERN VALUE
_wrap_new_SettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrency";
  
  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 ;
  FIX::SettlCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrency(FIX::SettlCurrency *arg1) {
    delete arg1;
}

swig_class cPegOffsetValue;

SWIGINTERN VALUE
_wrap_new_PegOffsetValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegOffsetValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetValue";
  
  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 ;
  FIX::PegOffsetValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::PegOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegOffsetValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegOffsetValue(FIX::PegOffsetValue *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityAltIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltIDSource";
  
  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 ;
  FIX::DerivativeSecurityAltIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityAltIDSource(FIX::DerivativeSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class cNoSettlPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoSettlPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSettlPartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartySubIDs";
  
  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 ;
  FIX::NoSettlPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSettlPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSettlPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSettlPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlPartySubIDs(FIX::NoSettlPartySubIDs *arg1) {
    delete arg1;
}

swig_class cAllocReportID;

SWIGINTERN VALUE
_wrap_new_AllocReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportID";
  
  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 ;
  FIX::AllocReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocReportID(FIX::AllocReportID *arg1) {
    delete arg1;
}

swig_class cLegCFICode;

SWIGINTERN VALUE
_wrap_new_LegCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCFICode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCFICode";
  
  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 ;
  FIX::LegCFICode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCFICode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCFICode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCFICode(FIX::LegCFICode *arg1) {
    delete arg1;
}

swig_class cLegFutSettDate;

SWIGINTERN VALUE
_wrap_new_LegFutSettDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegFutSettDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFutSettDate";
  
  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 ;
  FIX::LegFutSettDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFutSettDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegFutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegFutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegFutSettDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegFutSettDate(FIX::LegFutSettDate *arg1) {
    delete arg1;
}

swig_class cLegBenchmarkCurveName;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurveName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegBenchmarkCurveName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveName";
  
  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 ;
  FIX::LegBenchmarkCurveName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegBenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegBenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegBenchmarkCurveName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkCurveName(FIX::LegBenchmarkCurveName *arg1) {
    delete arg1;
}

swig_class cClearingFeeIndicator;

SWIGINTERN VALUE
_wrap_new_ClearingFeeIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClearingFeeIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingFeeIndicator";
  
  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 ;
  FIX::ClearingFeeIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingFeeIndicator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClearingFeeIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingFeeIndicator(FIX::ClearingFeeIndicator *arg1) {
    delete arg1;
}

swig_class cBrokerOfCredit;

SWIGINTERN VALUE
_wrap_new_BrokerOfCredit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BrokerOfCredit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BrokerOfCredit";
  
  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 ;
  FIX::BrokerOfCredit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BrokerOfCredit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BrokerOfCredit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BrokerOfCredit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BrokerOfCredit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BrokerOfCredit(FIX::BrokerOfCredit *arg1) {
    delete arg1;
}

swig_class cSecurityListRefID;

SWIGINTERN VALUE
_wrap_new_SecurityListRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityListRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRefID";
  
  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 ;
  FIX::SecurityListRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityListRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityListRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityListRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListRefID(FIX::SecurityListRefID *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegMaturityTime;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegMaturityTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityTime";
  
  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 ;
  FIX::UnderlyingLegMaturityTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingLegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegMaturityTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegMaturityTime(FIX::UnderlyingLegMaturityTime *arg1) {
    delete arg1;
}

swig_class cNestedPartySubIDType;

SWIGINTERN VALUE
_wrap_new_NestedPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NestedPartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubIDType";
  
  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 ;
  FIX::NestedPartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NestedPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NestedPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NestedPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartySubIDType(FIX::NestedPartySubIDType *arg1) {
    delete arg1;
}

swig_class cBidType;

SWIGINTERN VALUE
_wrap_new_BidType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidType";
  
  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 ;
  FIX::BidType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BidType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidType(FIX::BidType *arg1) {
    delete arg1;
}

swig_class cMDEntryRefID;

SWIGINTERN VALUE
_wrap_new_MDEntryRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryRefID";
  
  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 ;
  FIX::MDEntryRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDEntryRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryRefID(FIX::MDEntryRefID *arg1) {
    delete arg1;
}

swig_class cUnderlyingUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingUnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasureQty";
  
  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 ;
  FIX::UnderlyingUnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingUnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingUnitOfMeasureQty(FIX::UnderlyingUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegMaturityDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegMaturityDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityDate";
  
  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 ;
  FIX::UnderlyingLegMaturityDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingLegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegMaturityDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegMaturityDate(FIX::UnderlyingLegMaturityDate *arg1) {
    delete arg1;
}

swig_class cStartTickPriceRange;

SWIGINTERN VALUE
_wrap_new_StartTickPriceRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StartTickPriceRange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartTickPriceRange";
  
  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 ;
  FIX::StartTickPriceRange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartTickPriceRange";
  
  if ((argc < 1) || (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), "in method '" "FIX::StartTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StartTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StartTickPriceRange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StartTickPriceRange(FIX::StartTickPriceRange *arg1) {
    delete arg1;
}

swig_class cLegContractSettlMonth;

SWIGINTERN VALUE
_wrap_new_LegContractSettlMonth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegContractSettlMonth *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractSettlMonth";
  
  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 ;
  FIX::LegContractSettlMonth *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractSettlMonth";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegContractSettlMonth'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegContractSettlMonth(FIX::LegContractSettlMonth *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecurityDesc;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityDesc";
  
  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 ;
  FIX::UnderlyingSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityDesc(FIX::UnderlyingSecurityDesc *arg1) {
    delete arg1;
}

swig_class cCashDistribPayRef;

SWIGINTERN VALUE
_wrap_new_CashDistribPayRef__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashDistribPayRef *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribPayRef";
  
  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 ;
  FIX::CashDistribPayRef *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribPayRef";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashDistribPayRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashDistribPayRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashDistribPayRef'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribPayRef(FIX::CashDistribPayRef *arg1) {
    delete arg1;
}

swig_class cQuotePriceType;

SWIGINTERN VALUE
_wrap_new_QuotePriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuotePriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuotePriceType";
  
  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 ;
  FIX::QuotePriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuotePriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuotePriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuotePriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuotePriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuotePriceType(FIX::QuotePriceType *arg1) {
    delete arg1;
}

swig_class cEncodedAllocText;

SWIGINTERN VALUE
_wrap_new_EncodedAllocText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedAllocText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocText";
  
  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 ;
  FIX::EncodedAllocText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocText";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedAllocText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedAllocText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedAllocText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedAllocText(FIX::EncodedAllocText *arg1) {
    delete arg1;
}

swig_class cUnderlyingMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingMaturityMonthYear *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityMonthYear";
  
  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 ;
  FIX::UnderlyingMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityMonthYear(FIX::UnderlyingMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cRiskWarningLevelPercent;

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


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

SWIGINTERN VALUE
_wrap_new_RiskWarningLevelPercent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RiskWarningLevelPercent *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskWarningLevelPercent";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::RiskWarningLevelPercent *)new FIX::RiskWarningLevelPercent((FIX::PERCENTAGE const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskWarningLevelPercent(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskWarningLevelPercent__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_RiskWarningLevelPercent__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskWarningLevelPercent'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskWarningLevelPercent(FIX::RiskWarningLevelPercent *arg1) {
    delete arg1;
}

swig_class cUnderlyingOriginalNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOriginalNotionalPercentageOutstanding";
  
  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 ;
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOriginalNotionalPercentageOutstanding";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingOriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingOriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingOriginalNotionalPercentageOutstanding'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingOriginalNotionalPercentageOutstanding(FIX::UnderlyingOriginalNotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class cMultilegPriceMethod;

SWIGINTERN VALUE
_wrap_new_MultilegPriceMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MultilegPriceMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultilegPriceMethod";
  
  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 ;
  FIX::MultilegPriceMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultilegPriceMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MultilegPriceMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MultilegPriceMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MultilegPriceMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MultilegPriceMethod(FIX::MultilegPriceMethod *arg1) {
    delete arg1;
}

swig_class cTotNoFills;

SWIGINTERN VALUE
_wrap_new_TotNoFills__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoFills *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoFills";
  
  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 ;
  FIX::TotNoFills *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoFills";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoFills" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoFills" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoFills'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoFills(FIX::TotNoFills *arg1) {
    delete arg1;
}

swig_class cDerivativeSettleOnOpenFlag;

SWIGINTERN VALUE
_wrap_new_DerivativeSettleOnOpenFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSettleOnOpenFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettleOnOpenFlag";
  
  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 ;
  FIX::DerivativeSettleOnOpenFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettleOnOpenFlag";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSettleOnOpenFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSettleOnOpenFlag(FIX::DerivativeSettleOnOpenFlag *arg1) {
    delete arg1;
}

swig_class cUnderlyingRepurchaseTerm;

SWIGINTERN VALUE
_wrap_new_UnderlyingRepurchaseTerm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingRepurchaseTerm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseTerm";
  
  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 ;
  FIX::UnderlyingRepurchaseTerm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseTerm";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingRepurchaseTerm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRepurchaseTerm(FIX::UnderlyingRepurchaseTerm *arg1) {
    delete arg1;
}

swig_class cRiskWarningLevelName;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskWarningLevelName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskWarningLevelName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskWarningLevelName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskWarningLevelName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskWarningLevelName(FIX::RiskWarningLevelName *arg1) {
    delete arg1;
}

swig_class cDerivativeCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_DerivativeCountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeCountryOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCountryOfIssue";
  
  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 ;
  FIX::DerivativeCountryOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCountryOfIssue";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeCountryOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeCountryOfIssue(FIX::DerivativeCountryOfIssue *arg1) {
    delete arg1;
}

swig_class cListMethod;

SWIGINTERN VALUE
_wrap_new_ListMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListMethod";
  
  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 ;
  FIX::ListMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListMethod(FIX::ListMethod *arg1) {
    delete arg1;
}

swig_class cUnderlyingCPProgram;

SWIGINTERN VALUE
_wrap_new_UnderlyingCPProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCPProgram *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPProgram";
  
  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 ;
  FIX::UnderlyingCPProgram *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPProgram";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingCPProgram" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCPProgram" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCPProgram'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCPProgram(FIX::UnderlyingCPProgram *arg1) {
    delete arg1;
}

swig_class cPriceDelta;

SWIGINTERN VALUE
_wrap_new_PriceDelta__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceDelta *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceDelta";
  
  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 ;
  FIX::PriceDelta *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceDelta";
  
  if ((argc < 1) || (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), "in method '" "FIX::PriceDelta" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceDelta" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceDelta'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceDelta(FIX::PriceDelta *arg1) {
    delete arg1;
}

swig_class cRefSeqNum;

SWIGINTERN VALUE
_wrap_new_RefSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefSeqNum";
  
  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 ;
  FIX::RefSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::RefSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefSeqNum(FIX::RefSeqNum *arg1) {
    delete arg1;
}

swig_class cAutoAcceptIndicator;

SWIGINTERN VALUE
_wrap_new_AutoAcceptIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AutoAcceptIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AutoAcceptIndicator";
  
  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 ;
  FIX::AutoAcceptIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AutoAcceptIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::AutoAcceptIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AutoAcceptIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AutoAcceptIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AutoAcceptIndicator(FIX::AutoAcceptIndicator *arg1) {
    delete arg1;
}

swig_class cMDImplicitDelete;

SWIGINTERN VALUE
_wrap_new_MDImplicitDelete__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDImplicitDelete *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDImplicitDelete";
  
  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 ;
  FIX::MDImplicitDelete *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDImplicitDelete";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDImplicitDelete" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDImplicitDelete" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDImplicitDelete'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDImplicitDelete(FIX::MDImplicitDelete *arg1) {
    delete arg1;
}

swig_class cNoStipulations;

SWIGINTERN VALUE
_wrap_new_NoStipulations__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoStipulations *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStipulations";
  
  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 ;
  FIX::NoStipulations *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStipulations";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoStipulations'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStipulations(FIX::NoStipulations *arg1) {
    delete arg1;
}

swig_class cClearingBusinessDate;

SWIGINTERN VALUE
_wrap_new_ClearingBusinessDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClearingBusinessDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingBusinessDate";
  
  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 ;
  FIX::ClearingBusinessDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingBusinessDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::ClearingBusinessDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClearingBusinessDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClearingBusinessDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingBusinessDate(FIX::ClearingBusinessDate *arg1) {
    delete arg1;
}

swig_class cNoRelationshipRiskLimits;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelationshipRiskLimits__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskLimits *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelationshipRiskLimits";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelationshipRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelationshipRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelationshipRiskLimits *)new FIX::NoRelationshipRiskLimits((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelationshipRiskLimits(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelationshipRiskLimits__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_NoRelationshipRiskLimits__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelationshipRiskLimits'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelationshipRiskLimits(FIX::NoRelationshipRiskLimits *arg1) {
    delete arg1;
}

swig_class cLocationID;

SWIGINTERN VALUE
_wrap_new_LocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LocationID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocationID";
  
  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 ;
  FIX::LocationID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocationID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LocationID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LocationID(FIX::LocationID *arg1) {
    delete arg1;
}

swig_class cCurrency;

SWIGINTERN VALUE
_wrap_new_Currency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Currency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Currency";
  
  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 ;
  FIX::Currency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Currency";
  
  if ((argc < 1) || (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), "in method '" "FIX::Currency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Currency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Currency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Currency(FIX::Currency *arg1) {
    delete arg1;
}

swig_class cRoutingType;

SWIGINTERN VALUE
_wrap_new_RoutingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RoutingType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoutingType";
  
  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 ;
  FIX::RoutingType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoutingType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RoutingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RoutingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RoutingType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RoutingType(FIX::RoutingType *arg1) {
    delete arg1;
}

swig_class cUnderlyingStrikePrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingStrikePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikePrice";
  
  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 ;
  FIX::UnderlyingStrikePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingStrikePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStrikePrice(FIX::UnderlyingStrikePrice *arg1) {
    delete arg1;
}

swig_class cBidTradeType;

SWIGINTERN VALUE
_wrap_new_BidTradeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidTradeType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidTradeType";
  
  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 ;
  FIX::BidTradeType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidTradeType";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidTradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidTradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidTradeType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidTradeType(FIX::BidTradeType *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskInstrumentOperator;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskInstrumentOperator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskInstrumentOperator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskInstrumentOperator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskInstrumentOperator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskInstrumentOperator(FIX::RelationshipRiskInstrumentOperator *arg1) {
    delete arg1;
}

swig_class cUnderlyingAttachmentPoint;

SWIGINTERN VALUE
_wrap_new_UnderlyingAttachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingAttachmentPoint *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAttachmentPoint";
  
  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 ;
  FIX::UnderlyingAttachmentPoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAttachmentPoint";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingAttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingAttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingAttachmentPoint'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingAttachmentPoint(FIX::UnderlyingAttachmentPoint *arg1) {
    delete arg1;
}

swig_class cTotNoRejQuotes;

SWIGINTERN VALUE
_wrap_new_TotNoRejQuotes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoRejQuotes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoRejQuotes";
  
  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 ;
  FIX::TotNoRejQuotes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoRejQuotes";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoRejQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoRejQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoRejQuotes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoRejQuotes(FIX::TotNoRejQuotes *arg1) {
    delete arg1;
}

swig_class cOrdStatusReqID;

SWIGINTERN VALUE
_wrap_new_OrdStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrdStatusReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdStatusReqID";
  
  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 ;
  FIX::OrdStatusReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdStatusReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrdStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrdStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrdStatusReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdStatusReqID(FIX::OrdStatusReqID *arg1) {
    delete arg1;
}

swig_class cSenderCompID;

SWIGINTERN VALUE
_wrap_new_SenderCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SenderCompID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderCompID";
  
  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 ;
  FIX::SenderCompID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderCompID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SenderCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SenderCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SenderCompID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SenderCompID(FIX::SenderCompID *arg1) {
    delete arg1;
}

swig_class cOrdRejReason;

SWIGINTERN VALUE
_wrap_new_OrdRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrdRejReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdRejReason";
  
  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 ;
  FIX::OrdRejReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdRejReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrdRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrdRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrdRejReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdRejReason(FIX::OrdRejReason *arg1) {
    delete arg1;
}

swig_class cMaturityMonthYearIncrementUnits;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearIncrementUnits__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityMonthYearIncrementUnits *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrementUnits";
  
  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 ;
  FIX::MaturityMonthYearIncrementUnits *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearIncrementUnits";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MaturityMonthYearIncrementUnits" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityMonthYearIncrementUnits" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityMonthYearIncrementUnits'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYearIncrementUnits(FIX::MaturityMonthYearIncrementUnits *arg1) {
    delete arg1;
}

swig_class cDisplayWhen;

SWIGINTERN VALUE
_wrap_new_DisplayWhen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DisplayWhen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayWhen";
  
  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 ;
  FIX::DisplayWhen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayWhen";
  
  if ((argc < 1) || (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), "in method '" "FIX::DisplayWhen" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DisplayWhen" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DisplayWhen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayWhen(FIX::DisplayWhen *arg1) {
    delete arg1;
}

swig_class cApplQueueAction;

SWIGINTERN VALUE
_wrap_new_ApplQueueAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplQueueAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueAction";
  
  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 ;
  FIX::ApplQueueAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueAction";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplQueueAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplQueueAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplQueueAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueAction(FIX::ApplQueueAction *arg1) {
    delete arg1;
}

swig_class cRegistTransType;

SWIGINTERN VALUE
_wrap_new_RegistTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistTransType";
  
  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 ;
  FIX::RegistTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistTransType";
  
  if ((argc < 1) || (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), "in method '" "FIX::RegistTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistTransType(FIX::RegistTransType *arg1) {
    delete arg1;
}

swig_class cPaymentRemitterID;

SWIGINTERN VALUE
_wrap_new_PaymentRemitterID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PaymentRemitterID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentRemitterID";
  
  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 ;
  FIX::PaymentRemitterID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentRemitterID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PaymentRemitterID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PaymentRemitterID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PaymentRemitterID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentRemitterID(FIX::PaymentRemitterID *arg1) {
    delete arg1;
}

swig_class cPriceType;

SWIGINTERN VALUE
_wrap_new_PriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceType";
  
  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 ;
  FIX::PriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceType(FIX::PriceType *arg1) {
    delete arg1;
}

swig_class cMarketReqID;

SWIGINTERN VALUE
_wrap_new_MarketReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarketReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketReqID";
  
  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 ;
  FIX::MarketReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MarketReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarketReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarketReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketReqID(FIX::MarketReqID *arg1) {
    delete arg1;
}

swig_class cNoNestedInstrAttrib;

SWIGINTERN VALUE
_wrap_new_NoNestedInstrAttrib__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNestedInstrAttrib *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedInstrAttrib";
  
  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 ;
  FIX::NoNestedInstrAttrib *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedInstrAttrib";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNestedInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNestedInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNestedInstrAttrib'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNestedInstrAttrib(FIX::NoNestedInstrAttrib *arg1) {
    delete arg1;
}

swig_class cSecuritySubType;

SWIGINTERN VALUE
_wrap_new_SecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecuritySubType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySubType";
  
  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 ;
  FIX::SecuritySubType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySubType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecuritySubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySubType(FIX::SecuritySubType *arg1) {
    delete arg1;
}

swig_class cClOrdID;

SWIGINTERN VALUE
_wrap_new_ClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClOrdID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClOrdID";
  
  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 ;
  FIX::ClOrdID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClOrdID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClOrdID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClOrdID(FIX::ClOrdID *arg1) {
    delete arg1;
}

swig_class cMaturityDay;

SWIGINTERN VALUE
_wrap_new_MaturityDay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityDay *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityDay";
  
  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 ;
  FIX::MaturityDay *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityDay";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityDay'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityDay(FIX::MaturityDay *arg1) {
    delete arg1;
}

swig_class cUnderlyingSeniority;

SWIGINTERN VALUE
_wrap_new_UnderlyingSeniority__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSeniority *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSeniority";
  
  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 ;
  FIX::UnderlyingSeniority *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSeniority";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSeniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSeniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSeniority'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSeniority(FIX::UnderlyingSeniority *arg1) {
    delete arg1;
}

swig_class cMarketSegmentDesc;

SWIGINTERN VALUE
_wrap_new_MarketSegmentDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarketSegmentDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentDesc";
  
  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 ;
  FIX::MarketSegmentDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MarketSegmentDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarketSegmentDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarketSegmentDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketSegmentDesc(FIX::MarketSegmentDesc *arg1) {
    delete arg1;
}

swig_class cNoMarketSegments;

SWIGINTERN VALUE
_wrap_new_NoMarketSegments__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMarketSegments *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMarketSegments";
  
  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 ;
  FIX::NoMarketSegments *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMarketSegments";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMarketSegments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMarketSegments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMarketSegments'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMarketSegments(FIX::NoMarketSegments *arg1) {
    delete arg1;
}

swig_class cSettlObligMode;

SWIGINTERN VALUE
_wrap_new_SettlObligMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlObligMode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMode";
  
  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 ;
  FIX::SettlObligMode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlObligMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlObligMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlObligMode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligMode(FIX::SettlObligMode *arg1) {
    delete arg1;
}

swig_class cSecurityUpdateAction;

SWIGINTERN VALUE
_wrap_new_SecurityUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityUpdateAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityUpdateAction";
  
  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 ;
  FIX::SecurityUpdateAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityUpdateAction";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecurityUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityUpdateAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityUpdateAction(FIX::SecurityUpdateAction *arg1) {
    delete arg1;
}

swig_class cNetworkRequestType;

SWIGINTERN VALUE
_wrap_new_NetworkRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NetworkRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestType";
  
  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 ;
  FIX::NetworkRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NetworkRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NetworkRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetworkRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkRequestType(FIX::NetworkRequestType *arg1) {
    delete arg1;
}

swig_class cLiquidityPctLow;

SWIGINTERN VALUE
_wrap_new_LiquidityPctLow__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LiquidityPctLow *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctLow";
  
  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 ;
  FIX::LiquidityPctLow *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctLow";
  
  if ((argc < 1) || (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), "in method '" "FIX::LiquidityPctLow" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LiquidityPctLow" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LiquidityPctLow'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityPctLow(FIX::LiquidityPctLow *arg1) {
    delete arg1;
}

swig_class cPartyRole;

SWIGINTERN VALUE
_wrap_new_PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyRole";
  
  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 ;
  FIX::PartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyRole(FIX::PartyRole *arg1) {
    delete arg1;
}

swig_class cLegRatioQty;

SWIGINTERN VALUE
_wrap_new_LegRatioQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegRatioQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRatioQty";
  
  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 ;
  FIX::LegRatioQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRatioQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegRatioQty" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegRatioQty" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegRatioQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRatioQty(FIX::LegRatioQty *arg1) {
    delete arg1;
}

swig_class cSettlCurrFxRate;

SWIGINTERN VALUE
_wrap_new_SettlCurrFxRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlCurrFxRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRate";
  
  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 ;
  FIX::SettlCurrFxRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlCurrFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlCurrFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlCurrFxRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrFxRate(FIX::SettlCurrFxRate *arg1) {
    delete arg1;
}

swig_class cRelatedPartyRole;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartyRole(FIX::RelatedPartyRole *arg1) {
    delete arg1;
}

swig_class cLegContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_LegContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegContractMultiplierUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplierUnit";
  
  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 ;
  FIX::LegContractMultiplierUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplierUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegContractMultiplierUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegContractMultiplierUnit(FIX::LegContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class cSecureData;

SWIGINTERN VALUE
_wrap_new_SecureData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecureData *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecureData";
  
  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 ;
  FIX::SecureData *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecureData";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecureData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecureData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecureData'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecureData(FIX::SecureData *arg1) {
    delete arg1;
}

swig_class cSenderLocationID;

SWIGINTERN VALUE
_wrap_new_SenderLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SenderLocationID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderLocationID";
  
  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 ;
  FIX::SenderLocationID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderLocationID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SenderLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SenderLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SenderLocationID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SenderLocationID(FIX::SenderLocationID *arg1) {
    delete arg1;
}

swig_class cFirstPx;

SWIGINTERN VALUE
_wrap_new_FirstPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FirstPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FirstPx";
  
  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 ;
  FIX::FirstPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FirstPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::FirstPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FirstPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FirstPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FirstPx(FIX::FirstPx *arg1) {
    delete arg1;
}

swig_class cEncodedLegIssuer;

SWIGINTERN VALUE
_wrap_new_EncodedLegIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedLegIssuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuer";
  
  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 ;
  FIX::EncodedLegIssuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuer";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedLegIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedLegIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedLegIssuer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegIssuer(FIX::EncodedLegIssuer *arg1) {
    delete arg1;
}

swig_class cAssignmentMethod;

SWIGINTERN VALUE
_wrap_new_AssignmentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AssignmentMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AssignmentMethod";
  
  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 ;
  FIX::AssignmentMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AssignmentMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::AssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AssignmentMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AssignmentMethod(FIX::AssignmentMethod *arg1) {
    delete arg1;
}

swig_class cRoutingID;

SWIGINTERN VALUE
_wrap_new_RoutingID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RoutingID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoutingID";
  
  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 ;
  FIX::RoutingID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoutingID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RoutingID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RoutingID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RoutingID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RoutingID(FIX::RoutingID *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityAltID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityAltID(FIX::RelationshipRiskSecurityAltID *arg1) {
    delete arg1;
}

swig_class cRelatedPartyAltID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedPartyAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartyAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedPartyAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartyAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartyAltID(FIX::RelatedPartyAltID *arg1) {
    delete arg1;
}

swig_class cStrategyParameterType;

SWIGINTERN VALUE
_wrap_new_StrategyParameterType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrategyParameterType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterType";
  
  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 ;
  FIX::StrategyParameterType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StrategyParameterType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrategyParameterType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrategyParameterType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrategyParameterType(FIX::StrategyParameterType *arg1) {
    delete arg1;
}

swig_class cEncryptMethod;

SWIGINTERN VALUE
_wrap_new_EncryptMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncryptMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptMethod";
  
  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 ;
  FIX::EncryptMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::EncryptMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncryptMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncryptMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptMethod(FIX::EncryptMethod *arg1) {
    delete arg1;
}

swig_class cUnderlyingStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingStateOrProvinceOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStateOrProvinceOfIssue";
  
  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 ;
  FIX::UnderlyingStateOrProvinceOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStateOrProvinceOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingStateOrProvinceOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStateOrProvinceOfIssue(FIX::UnderlyingStateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class cApplNewSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplNewSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplNewSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplNewSeqNum";
  
  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 ;
  FIX::ApplNewSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplNewSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::ApplNewSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplNewSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplNewSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplNewSeqNum(FIX::ApplNewSeqNum *arg1) {
    delete arg1;
}

swig_class cDerivativeEncodedSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEncodedSecurityDescLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDescLen";
  
  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 ;
  FIX::DerivativeEncodedSecurityDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEncodedSecurityDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEncodedSecurityDescLen(FIX::DerivativeEncodedSecurityDescLen *arg1) {
    delete arg1;
}

swig_class cTradingCurrency;

SWIGINTERN VALUE
_wrap_new_TradingCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradingCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingCurrency";
  
  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 ;
  FIX::TradingCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradingCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingCurrency(FIX::TradingCurrency *arg1) {
    delete arg1;
}

swig_class cSecondaryHighLimitPrice;

SWIGINTERN VALUE
_wrap_new_SecondaryHighLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryHighLimitPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryHighLimitPrice";
  
  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 ;
  FIX::SecondaryHighLimitPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryHighLimitPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecondaryHighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryHighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryHighLimitPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryHighLimitPrice(FIX::SecondaryHighLimitPrice *arg1) {
    delete arg1;
}

swig_class cOrderAvgPx;

SWIGINTERN VALUE
_wrap_new_OrderAvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderAvgPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderAvgPx";
  
  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 ;
  FIX::OrderAvgPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderAvgPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderAvgPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderAvgPx(FIX::OrderAvgPx *arg1) {
    delete arg1;
}

swig_class cPosAmtType;

SWIGINTERN VALUE
_wrap_new_PosAmtType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosAmtType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosAmtType";
  
  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 ;
  FIX::PosAmtType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosAmtType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosAmtType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosAmtType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosAmtType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosAmtType(FIX::PosAmtType *arg1) {
    delete arg1;
}

swig_class cResetSeqNumFlag;

SWIGINTERN VALUE
_wrap_new_ResetSeqNumFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ResetSeqNumFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResetSeqNumFlag";
  
  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 ;
  FIX::ResetSeqNumFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResetSeqNumFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::ResetSeqNumFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ResetSeqNumFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ResetSeqNumFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ResetSeqNumFlag(FIX::ResetSeqNumFlag *arg1) {
    delete arg1;
}

swig_class cNoHops;

SWIGINTERN VALUE
_wrap_new_NoHops__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoHops *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoHops";
  
  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 ;
  FIX::NoHops *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoHops";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoHops" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoHops" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoHops'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoHops(FIX::NoHops *arg1) {
    delete arg1;
}

swig_class cCollInquiryResult;

SWIGINTERN VALUE
_wrap_new_CollInquiryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollInquiryResult *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryResult";
  
  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 ;
  FIX::CollInquiryResult *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryResult";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollInquiryResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollInquiryResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollInquiryResult'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryResult(FIX::CollInquiryResult *arg1) {
    delete arg1;
}

swig_class cStartDate;

SWIGINTERN VALUE
_wrap_new_StartDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StartDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartDate";
  
  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 ;
  FIX::StartDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::StartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StartDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StartDate(FIX::StartDate *arg1) {
    delete arg1;
}

swig_class cCollAsgnRespType;

SWIGINTERN VALUE
_wrap_new_CollAsgnRespType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollAsgnRespType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRespType";
  
  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 ;
  FIX::CollAsgnRespType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRespType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollAsgnRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollAsgnRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollAsgnRespType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnRespType(FIX::CollAsgnRespType *arg1) {
    delete arg1;
}

swig_class cOrderBookingQty;

SWIGINTERN VALUE
_wrap_new_OrderBookingQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderBookingQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderBookingQty";
  
  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 ;
  FIX::OrderBookingQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderBookingQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderBookingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderBookingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderBookingQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderBookingQty(FIX::OrderBookingQty *arg1) {
    delete arg1;
}

swig_class cNoQuoteQualifiers;

SWIGINTERN VALUE
_wrap_new_NoQuoteQualifiers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoQuoteQualifiers *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteQualifiers";
  
  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 ;
  FIX::NoQuoteQualifiers *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteQualifiers";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoQuoteQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoQuoteQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoQuoteQualifiers'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoQuoteQualifiers(FIX::NoQuoteQualifiers *arg1) {
    delete arg1;
}

swig_class cUnsolicitedIndicator;

SWIGINTERN VALUE
_wrap_new_UnsolicitedIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnsolicitedIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnsolicitedIndicator";
  
  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 ;
  FIX::UnsolicitedIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnsolicitedIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnsolicitedIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnsolicitedIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnsolicitedIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnsolicitedIndicator(FIX::UnsolicitedIndicator *arg1) {
    delete arg1;
}

swig_class cRefCstmApplVerID;

SWIGINTERN VALUE
_wrap_new_RefCstmApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefCstmApplVerID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefCstmApplVerID";
  
  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 ;
  FIX::RefCstmApplVerID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefCstmApplVerID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefCstmApplVerID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefCstmApplVerID(FIX::RefCstmApplVerID *arg1) {
    delete arg1;
}

swig_class cSideExecID;

SWIGINTERN VALUE
_wrap_new_SideExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideExecID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideExecID";
  
  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 ;
  FIX::SideExecID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideExecID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideExecID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideExecID(FIX::SideExecID *arg1) {
    delete arg1;
}

swig_class cRejectText;

SWIGINTERN VALUE
_wrap_new_RejectText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RejectText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RejectText";
  
  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 ;
  FIX::RejectText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RejectText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RejectText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RejectText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RejectText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RejectText(FIX::RejectText *arg1) {
    delete arg1;
}

swig_class cExchangeSpecialInstructions;

SWIGINTERN VALUE
_wrap_new_ExchangeSpecialInstructions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExchangeSpecialInstructions *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeSpecialInstructions";
  
  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 ;
  FIX::ExchangeSpecialInstructions *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeSpecialInstructions";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExchangeSpecialInstructions" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExchangeSpecialInstructions" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExchangeSpecialInstructions'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExchangeSpecialInstructions(FIX::ExchangeSpecialInstructions *arg1) {
    delete arg1;
}

swig_class cTradeID;

SWIGINTERN VALUE
_wrap_new_TradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeID";
  
  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 ;
  FIX::TradeID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeID(FIX::TradeID *arg1) {
    delete arg1;
}

swig_class cRndPx;

SWIGINTERN VALUE
_wrap_new_RndPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RndPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RndPx";
  
  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 ;
  FIX::RndPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RndPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::RndPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RndPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RndPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RndPx(FIX::RndPx *arg1) {
    delete arg1;
}

swig_class cQuoteEntryRejectReason;

SWIGINTERN VALUE
_wrap_new_QuoteEntryRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteEntryRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryRejectReason";
  
  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 ;
  FIX::QuoteEntryRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteEntryRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteEntryRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteEntryRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteEntryRejectReason(FIX::QuoteEntryRejectReason *arg1) {
    delete arg1;
}

swig_class cOrderCapacity;

SWIGINTERN VALUE
_wrap_new_OrderCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderCapacity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacity";
  
  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 ;
  FIX::OrderCapacity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacity";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderCapacity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderCapacity(FIX::OrderCapacity *arg1) {
    delete arg1;
}

swig_class cSideLastQty;

SWIGINTERN VALUE
_wrap_new_SideLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideLastQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideLastQty";
  
  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 ;
  FIX::SideLastQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideLastQty";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideLastQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideLastQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideLastQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideLastQty(FIX::SideLastQty *arg1) {
    delete arg1;
}

swig_class cDerivativeUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_DerivativeUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeUnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasure";
  
  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 ;
  FIX::DerivativeUnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeUnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeUnitOfMeasure(FIX::DerivativeUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cNoLegAllocs;

SWIGINTERN VALUE
_wrap_new_NoLegAllocs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoLegAllocs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegAllocs";
  
  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 ;
  FIX::NoLegAllocs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegAllocs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoLegAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoLegAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoLegAllocs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegAllocs(FIX::NoLegAllocs *arg1) {
    delete arg1;
}

swig_class cQuoteAckStatus;

SWIGINTERN VALUE
_wrap_new_QuoteAckStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteAckStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteAckStatus";
  
  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 ;
  FIX::QuoteAckStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteAckStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteAckStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteAckStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteAckStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteAckStatus(FIX::QuoteAckStatus *arg1) {
    delete arg1;
}

swig_class cSecondaryFirmTradeID;

SWIGINTERN VALUE
_wrap_new_SecondaryFirmTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryFirmTradeID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryFirmTradeID";
  
  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 ;
  FIX::SecondaryFirmTradeID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryFirmTradeID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryFirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryFirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryFirmTradeID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryFirmTradeID(FIX::SecondaryFirmTradeID *arg1) {
    delete arg1;
}

swig_class cUserRequestType;

SWIGINTERN VALUE
_wrap_new_UserRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UserRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserRequestType";
  
  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 ;
  FIX::UserRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserRequestType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UserRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UserRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UserRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UserRequestType(FIX::UserRequestType *arg1) {
    delete arg1;
}

swig_class cSecondaryTrdType;

SWIGINTERN VALUE
_wrap_new_SecondaryTrdType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryTrdType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTrdType";
  
  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 ;
  FIX::SecondaryTrdType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTrdType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryTrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryTrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryTrdType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTrdType(FIX::SecondaryTrdType *arg1) {
    delete arg1;
}

swig_class cTradeReportTransType;

SWIGINTERN VALUE
_wrap_new_TradeReportTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeReportTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportTransType";
  
  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 ;
  FIX::TradeReportTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportTransType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeReportTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeReportTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeReportTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportTransType(FIX::TradeReportTransType *arg1) {
    delete arg1;
}

swig_class cAdvSide;

SWIGINTERN VALUE
_wrap_new_AdvSide__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AdvSide *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvSide";
  
  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 ;
  FIX::AdvSide *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvSide";
  
  if ((argc < 1) || (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), "in method '" "FIX::AdvSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AdvSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AdvSide'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvSide(FIX::AdvSide *arg1) {
    delete arg1;
}

swig_class cRelatedContextPartySubID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedContextPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedContextPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedContextPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedContextPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedContextPartySubID(FIX::RelatedContextPartySubID *arg1) {
    delete arg1;
}

swig_class cDerivativeSecuritySubType;

SWIGINTERN VALUE
_wrap_new_DerivativeSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecuritySubType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecuritySubType";
  
  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 ;
  FIX::DerivativeSecuritySubType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecuritySubType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecuritySubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecuritySubType(FIX::DerivativeSecuritySubType *arg1) {
    delete arg1;
}

swig_class cTriggerTradingSessionSubID;

SWIGINTERN VALUE
_wrap_new_TriggerTradingSessionSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerTradingSessionSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionSubID";
  
  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 ;
  FIX::TriggerTradingSessionSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TriggerTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerTradingSessionSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerTradingSessionSubID(FIX::TriggerTradingSessionSubID *arg1) {
    delete arg1;
}

swig_class cTradeLinkID;

SWIGINTERN VALUE
_wrap_new_TradeLinkID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeLinkID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeLinkID";
  
  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 ;
  FIX::TradeLinkID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeLinkID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeLinkID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeLinkID(FIX::TradeLinkID *arg1) {
    delete arg1;
}

swig_class cLegBenchmarkPrice;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegBenchmarkPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPrice";
  
  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 ;
  FIX::LegBenchmarkPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegBenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegBenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegBenchmarkPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkPrice(FIX::LegBenchmarkPrice *arg1) {
    delete arg1;
}

swig_class cHopRefID;

SWIGINTERN VALUE
_wrap_new_HopRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HopRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopRefID";
  
  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 ;
  FIX::HopRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopRefID";
  
  if ((argc < 1) || (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), "in method '" "FIX::HopRefID" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HopRefID" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HopRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HopRefID(FIX::HopRefID *arg1) {
    delete arg1;
}

swig_class cDesignation;

SWIGINTERN VALUE
_wrap_new_Designation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Designation *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Designation";
  
  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 ;
  FIX::Designation *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Designation";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Designation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Designation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Designation'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Designation(FIX::Designation *arg1) {
    delete arg1;
}

swig_class cTradeRequestID;

SWIGINTERN VALUE
_wrap_new_TradeRequestID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeRequestID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestID";
  
  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 ;
  FIX::TradeRequestID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeRequestID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestID(FIX::TradeRequestID *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskLimitType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskLimitType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskLimitType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskLimitType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskLimitType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskLimitType(FIX::RelationshipRiskLimitType *arg1) {
    delete arg1;
}

swig_class cRiskSecurityIDSource;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityIDSource(FIX::RiskSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cLegFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_LegFlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegFlowScheduleType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFlowScheduleType";
  
  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 ;
  FIX::LegFlowScheduleType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFlowScheduleType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegFlowScheduleType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegFlowScheduleType(FIX::LegFlowScheduleType *arg1) {
    delete arg1;
}

swig_class cLegPriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_LegPriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegPriceUnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasure";
  
  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 ;
  FIX::LegPriceUnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegPriceUnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPriceUnitOfMeasure(FIX::LegPriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cNested4PartyIDSource;

SWIGINTERN VALUE
_wrap_new_Nested4PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested4PartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyIDSource";
  
  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 ;
  FIX::Nested4PartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::Nested4PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested4PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested4PartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartyIDSource(FIX::Nested4PartyIDSource *arg1) {
    delete arg1;
}

swig_class cCoveredOrUncovered;

SWIGINTERN VALUE
_wrap_new_CoveredOrUncovered__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CoveredOrUncovered *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CoveredOrUncovered";
  
  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 ;
  FIX::CoveredOrUncovered *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CoveredOrUncovered";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CoveredOrUncovered'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CoveredOrUncovered(FIX::CoveredOrUncovered *arg1) {
    delete arg1;
}

swig_class cAcctIDSource;

SWIGINTERN VALUE
_wrap_new_AcctIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AcctIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AcctIDSource";
  
  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 ;
  FIX::AcctIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AcctIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AcctIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AcctIDSource(FIX::AcctIDSource *arg1) {
    delete arg1;
}

swig_class cMktOfferPx;

SWIGINTERN VALUE
_wrap_new_MktOfferPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MktOfferPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MktOfferPx";
  
  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 ;
  FIX::MktOfferPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MktOfferPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::MktOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MktOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MktOfferPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MktOfferPx(FIX::MktOfferPx *arg1) {
    delete arg1;
}

swig_class cNoCapacities;

SWIGINTERN VALUE
_wrap_new_NoCapacities__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoCapacities *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCapacities";
  
  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 ;
  FIX::NoCapacities *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCapacities";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoCapacities" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoCapacities" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoCapacities'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoCapacities(FIX::NoCapacities *arg1) {
    delete arg1;
}

swig_class cTradeRequestType;

SWIGINTERN VALUE
_wrap_new_TradeRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestType";
  
  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 ;
  FIX::TradeRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestType(FIX::TradeRequestType *arg1) {
    delete arg1;
}

swig_class cNoNestedPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNestedPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNestedPartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartyIDs";
  
  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 ;
  FIX::NoNestedPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNestedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNestedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNestedPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNestedPartyIDs(FIX::NoNestedPartyIDs *arg1) {
    delete arg1;
}

swig_class cTradSesStatus;

SWIGINTERN VALUE
_wrap_new_TradSesStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatus";
  
  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 ;
  FIX::TradSesStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradSesStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesStatus(FIX::TradSesStatus *arg1) {
    delete arg1;
}

swig_class cUnderlyingNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingNotionalPercentageOutstanding *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingNotionalPercentageOutstanding";
  
  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 ;
  FIX::UnderlyingNotionalPercentageOutstanding *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingNotionalPercentageOutstanding";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingNotionalPercentageOutstanding'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingNotionalPercentageOutstanding(FIX::UnderlyingNotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class cApplLastSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplLastSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplLastSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplLastSeqNum";
  
  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 ;
  FIX::ApplLastSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplLastSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::ApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplLastSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplLastSeqNum(FIX::ApplLastSeqNum *arg1) {
    delete arg1;
}

swig_class cPegPriceType;

SWIGINTERN VALUE
_wrap_new_PegPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegPriceType";
  
  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 ;
  FIX::PegPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegPriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegPriceType(FIX::PegPriceType *arg1) {
    delete arg1;
}

swig_class cStrategyParameterName;

SWIGINTERN VALUE
_wrap_new_StrategyParameterName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrategyParameterName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterName";
  
  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 ;
  FIX::StrategyParameterName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StrategyParameterName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrategyParameterName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrategyParameterName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrategyParameterName(FIX::StrategyParameterName *arg1) {
    delete arg1;
}

swig_class cStreamAsgnRejReason;

SWIGINTERN VALUE
_wrap_new_StreamAsgnRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StreamAsgnRejReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRejReason";
  
  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 ;
  FIX::StreamAsgnRejReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRejReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StreamAsgnRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StreamAsgnRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StreamAsgnRejReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnRejReason(FIX::StreamAsgnRejReason *arg1) {
    delete arg1;
}

swig_class cMatchIncrement;

SWIGINTERN VALUE
_wrap_new_MatchIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MatchIncrement *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchIncrement";
  
  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 ;
  FIX::MatchIncrement *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchIncrement";
  
  if ((argc < 1) || (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), "in method '" "FIX::MatchIncrement" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MatchIncrement" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MatchIncrement'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchIncrement(FIX::MatchIncrement *arg1) {
    delete arg1;
}

swig_class cNested3PartyRole;

SWIGINTERN VALUE
_wrap_new_Nested3PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested3PartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyRole";
  
  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 ;
  FIX::Nested3PartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested3PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested3PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested3PartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartyRole(FIX::Nested3PartyRole *arg1) {
    delete arg1;
}

swig_class cUnderlyingPx;

SWIGINTERN VALUE
_wrap_new_UnderlyingPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPx";
  
  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 ;
  FIX::UnderlyingPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPx(FIX::UnderlyingPx *arg1) {
    delete arg1;
}

swig_class cPriceImprovement;

SWIGINTERN VALUE
_wrap_new_PriceImprovement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceImprovement *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceImprovement";
  
  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 ;
  FIX::PriceImprovement *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceImprovement";
  
  if ((argc < 1) || (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), "in method '" "FIX::PriceImprovement" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceImprovement" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceImprovement'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceImprovement(FIX::PriceImprovement *arg1) {
    delete arg1;
}

swig_class cValuationMethod;

SWIGINTERN VALUE
_wrap_new_ValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ValuationMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValuationMethod";
  
  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 ;
  FIX::ValuationMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValuationMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ValuationMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ValuationMethod(FIX::ValuationMethod *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityID;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityID";
  
  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 ;
  FIX::DerivativeSecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityID(FIX::DerivativeSecurityID *arg1) {
    delete arg1;
}

swig_class cNoExpiration;

SWIGINTERN VALUE
_wrap_new_NoExpiration__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoExpiration *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExpiration";
  
  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 ;
  FIX::NoExpiration *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExpiration";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoExpiration" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoExpiration" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoExpiration'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoExpiration(FIX::NoExpiration *arg1) {
    delete arg1;
}

swig_class cTargetCompID;

SWIGINTERN VALUE
_wrap_new_TargetCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetCompID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetCompID";
  
  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 ;
  FIX::TargetCompID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetCompID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TargetCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetCompID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetCompID(FIX::TargetCompID *arg1) {
    delete arg1;
}

swig_class cMDEntryBuyer;

SWIGINTERN VALUE
_wrap_new_MDEntryBuyer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryBuyer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryBuyer";
  
  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 ;
  FIX::MDEntryBuyer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryBuyer";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDEntryBuyer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryBuyer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryBuyer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryBuyer(FIX::MDEntryBuyer *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskCouponRate;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskCouponRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RelationshipRiskCouponRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskCouponRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::RelationshipRiskCouponRate *)new FIX::RelationshipRiskCouponRate((FIX::PERCENTAGE const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskCouponRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskCouponRate__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_RelationshipRiskCouponRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskCouponRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskCouponRate(FIX::RelationshipRiskCouponRate *arg1) {
    delete arg1;
}

swig_class cNoDerivativeInstrumentPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDerivativeInstrumentPartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentPartySubIDs";
  
  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 ;
  FIX::NoDerivativeInstrumentPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoDerivativeInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDerivativeInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDerivativeInstrumentPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeInstrumentPartySubIDs(FIX::NoDerivativeInstrumentPartySubIDs *arg1) {
    delete arg1;
}

swig_class cNoMaturityRules;

SWIGINTERN VALUE
_wrap_new_NoMaturityRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMaturityRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMaturityRules";
  
  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 ;
  FIX::NoMaturityRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMaturityRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMaturityRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMaturityRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMaturityRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMaturityRules(FIX::NoMaturityRules *arg1) {
    delete arg1;
}

swig_class cQuoteMsgID;

SWIGINTERN VALUE
_wrap_new_QuoteMsgID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteMsgID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteMsgID";
  
  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 ;
  FIX::QuoteMsgID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteMsgID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteMsgID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteMsgID(FIX::QuoteMsgID *arg1) {
    delete arg1;
}

swig_class cTriggerType;

SWIGINTERN VALUE
_wrap_new_TriggerType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerType";
  
  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 ;
  FIX::TriggerType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerType";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerType(FIX::TriggerType *arg1) {
    delete arg1;
}

swig_class cPriceProtectionScope;

SWIGINTERN VALUE
_wrap_new_PriceProtectionScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceProtectionScope *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceProtectionScope";
  
  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 ;
  FIX::PriceProtectionScope *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceProtectionScope";
  
  if ((argc < 1) || (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), "in method '" "FIX::PriceProtectionScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceProtectionScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceProtectionScope'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceProtectionScope(FIX::PriceProtectionScope *arg1) {
    delete arg1;
}

swig_class cTotNumAssignmentReports;

SWIGINTERN VALUE
_wrap_new_TotNumAssignmentReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNumAssignmentReports *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumAssignmentReports";
  
  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 ;
  FIX::TotNumAssignmentReports *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumAssignmentReports";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNumAssignmentReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNumAssignmentReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNumAssignmentReports'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNumAssignmentReports(FIX::TotNumAssignmentReports *arg1) {
    delete arg1;
}

swig_class cContraLegRefID;

SWIGINTERN VALUE
_wrap_new_ContraLegRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContraLegRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraLegRefID";
  
  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 ;
  FIX::ContraLegRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraLegRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ContraLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContraLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContraLegRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraLegRefID(FIX::ContraLegRefID *arg1) {
    delete arg1;
}

swig_class cTradeReportRejectReason;

SWIGINTERN VALUE
_wrap_new_TradeReportRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeReportRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRejectReason";
  
  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 ;
  FIX::TradeReportRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeReportRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeReportRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeReportRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportRejectReason(FIX::TradeReportRejectReason *arg1) {
    delete arg1;
}

swig_class cTradeReportRefID;

SWIGINTERN VALUE
_wrap_new_TradeReportRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeReportRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRefID";
  
  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 ;
  FIX::TradeReportRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeReportRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportRefID(FIX::TradeReportRefID *arg1) {
    delete arg1;
}

swig_class cSecurityListType;

SWIGINTERN VALUE
_wrap_new_SecurityListType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityListType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListType";
  
  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 ;
  FIX::SecurityListType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityListType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityListType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityListType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListType(FIX::SecurityListType *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityIDSource";
  
  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 ;
  FIX::DerivativeSecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityIDSource(FIX::DerivativeSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cAssignmentUnit;

SWIGINTERN VALUE
_wrap_new_AssignmentUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AssignmentUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AssignmentUnit";
  
  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 ;
  FIX::AssignmentUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AssignmentUnit";
  
  if ((argc < 1) || (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), "in method '" "FIX::AssignmentUnit" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AssignmentUnit" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AssignmentUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AssignmentUnit(FIX::AssignmentUnit *arg1) {
    delete arg1;
}

swig_class cTradeReportID;

SWIGINTERN VALUE
_wrap_new_TradeReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportID";
  
  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 ;
  FIX::TradeReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportID(FIX::TradeReportID *arg1) {
    delete arg1;
}

swig_class cNoRpts;

SWIGINTERN VALUE
_wrap_new_NoRpts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoRpts *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRpts";
  
  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 ;
  FIX::NoRpts *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRpts";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NoRpts" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRpts" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRpts'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRpts(FIX::NoRpts *arg1) {
    delete arg1;
}

swig_class cLegBenchmarkPriceType;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegBenchmarkPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPriceType";
  
  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 ;
  FIX::LegBenchmarkPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkPriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegBenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegBenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegBenchmarkPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkPriceType(FIX::LegBenchmarkPriceType *arg1) {
    delete arg1;
}

swig_class cEncodedSubjectLen;

SWIGINTERN VALUE
_wrap_new_EncodedSubjectLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedSubjectLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubjectLen";
  
  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 ;
  FIX::EncodedSubjectLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubjectLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSubjectLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSubjectLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSubjectLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSubjectLen(FIX::EncodedSubjectLen *arg1) {
    delete arg1;
}

swig_class cSecurityXML;

SWIGINTERN VALUE
_wrap_new_SecurityXML__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityXML *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXML";
  
  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 ;
  FIX::SecurityXML *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXML";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecurityXML" "', argument " "1"" of type '" "FIX::XMLDATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityXML" "', argument " "1"" of type '" "FIX::XMLDATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityXML'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityXML(FIX::SecurityXML *arg1) {
    delete arg1;
}

swig_class cLegReportID;

SWIGINTERN VALUE
_wrap_new_LegReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegReportID";
  
  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 ;
  FIX::LegReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegReportID(FIX::LegReportID *arg1) {
    delete arg1;
}

swig_class cNested3PartySubIDType;

SWIGINTERN VALUE
_wrap_new_Nested3PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested3PartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubIDType";
  
  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 ;
  FIX::Nested3PartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested3PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested3PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested3PartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartySubIDType(FIX::Nested3PartySubIDType *arg1) {
    delete arg1;
}

swig_class cBenchmarkSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_BenchmarkSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BenchmarkSecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityIDSource";
  
  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 ;
  FIX::BenchmarkSecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BenchmarkSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BenchmarkSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BenchmarkSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkSecurityIDSource(FIX::BenchmarkSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cQuoteRejectReason;

SWIGINTERN VALUE
_wrap_new_QuoteRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRejectReason";
  
  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 ;
  FIX::QuoteRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRejectReason(FIX::QuoteRejectReason *arg1) {
    delete arg1;
}

swig_class cHeartBtInt;

SWIGINTERN VALUE
_wrap_new_HeartBtInt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HeartBtInt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HeartBtInt";
  
  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 ;
  FIX::HeartBtInt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HeartBtInt";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::HeartBtInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HeartBtInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HeartBtInt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HeartBtInt(FIX::HeartBtInt *arg1) {
    delete arg1;
}

swig_class cBidForwardPoints;

SWIGINTERN VALUE
_wrap_new_BidForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidForwardPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints";
  
  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 ;
  FIX::BidForwardPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidForwardPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidForwardPoints(FIX::BidForwardPoints *arg1) {
    delete arg1;
}

swig_class cPossResend;

SWIGINTERN VALUE
_wrap_new_PossResend__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PossResend *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PossResend";
  
  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 ;
  FIX::PossResend *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PossResend";
  
  if ((argc < 1) || (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), "in method '" "FIX::PossResend" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PossResend" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PossResend'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PossResend(FIX::PossResend *arg1) {
    delete arg1;
}

swig_class cSymbol;

SWIGINTERN VALUE
_wrap_new_Symbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Symbol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Symbol";
  
  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 ;
  FIX::Symbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Symbol";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Symbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Symbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Symbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Symbol(FIX::Symbol *arg1) {
    delete arg1;
}

swig_class cEncodedUnderlyingSecurityDesc;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedUnderlyingSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDesc";
  
  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 ;
  FIX::EncodedUnderlyingSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedUnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedUnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedUnderlyingSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingSecurityDesc(FIX::EncodedUnderlyingSecurityDesc *arg1) {
    delete arg1;
}

swig_class cRelatedPartyAltSubIDType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedPartyAltSubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartyAltSubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedPartyAltSubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartyAltSubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartyAltSubIDType(FIX::RelatedPartyAltSubIDType *arg1) {
    delete arg1;
}

swig_class cMarketReportID;

SWIGINTERN VALUE
_wrap_new_MarketReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarketReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketReportID";
  
  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 ;
  FIX::MarketReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MarketReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarketReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarketReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketReportID(FIX::MarketReportID *arg1) {
    delete arg1;
}

swig_class cDiscretionPrice;

SWIGINTERN VALUE
_wrap_new_DiscretionPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionPrice";
  
  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 ;
  FIX::DiscretionPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::DiscretionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionPrice(FIX::DiscretionPrice *arg1) {
    delete arg1;
}

swig_class cContAmtValue;

SWIGINTERN VALUE
_wrap_new_ContAmtValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContAmtValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtValue";
  
  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 ;
  FIX::ContAmtValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContAmtValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContAmtValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContAmtValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContAmtValue(FIX::ContAmtValue *arg1) {
    delete arg1;
}

swig_class cQuantityType;

SWIGINTERN VALUE
_wrap_new_QuantityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuantityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuantityType";
  
  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 ;
  FIX::QuantityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuantityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuantityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuantityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuantityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuantityType(FIX::QuantityType *arg1) {
    delete arg1;
}

swig_class cComplexEventPriceBoundaryMethod;

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceBoundaryMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventPriceBoundaryMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryMethod";
  
  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 ;
  FIX::ComplexEventPriceBoundaryMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ComplexEventPriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventPriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventPriceBoundaryMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPriceBoundaryMethod(FIX::ComplexEventPriceBoundaryMethod *arg1) {
    delete arg1;
}

swig_class cImpliedMarketIndicator;

SWIGINTERN VALUE
_wrap_new_ImpliedMarketIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ImpliedMarketIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ImpliedMarketIndicator";
  
  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 ;
  FIX::ImpliedMarketIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ImpliedMarketIndicator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ImpliedMarketIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ImpliedMarketIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ImpliedMarketIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ImpliedMarketIndicator(FIX::ImpliedMarketIndicator *arg1) {
    delete arg1;
}

swig_class cAllocClearingFeeIndicator;

SWIGINTERN VALUE
_wrap_new_AllocClearingFeeIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocClearingFeeIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocClearingFeeIndicator";
  
  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 ;
  FIX::AllocClearingFeeIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocClearingFeeIndicator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocClearingFeeIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocClearingFeeIndicator(FIX::AllocClearingFeeIndicator *arg1) {
    delete arg1;
}

swig_class cQuoteRequestType;

SWIGINTERN VALUE
_wrap_new_QuoteRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestType";
  
  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 ;
  FIX::QuoteRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRequestType(FIX::QuoteRequestType *arg1) {
    delete arg1;
}

swig_class cSecurityRequestResult;

SWIGINTERN VALUE
_wrap_new_SecurityRequestResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityRequestResult *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestResult";
  
  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 ;
  FIX::SecurityRequestResult *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestResult";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityRequestResult'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityRequestResult(FIX::SecurityRequestResult *arg1) {
    delete arg1;
}

swig_class cOrderRestrictions;

SWIGINTERN VALUE
_wrap_new_OrderRestrictions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderRestrictions *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderRestrictions";
  
  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 ;
  FIX::OrderRestrictions *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderRestrictions";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderRestrictions" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderRestrictions" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderRestrictions'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderRestrictions(FIX::OrderRestrictions *arg1) {
    delete arg1;
}

swig_class cNoSideTrdRegTS;

SWIGINTERN VALUE
_wrap_new_NoSideTrdRegTS__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSideTrdRegTS *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSideTrdRegTS";
  
  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 ;
  FIX::NoSideTrdRegTS *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSideTrdRegTS";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSideTrdRegTS" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSideTrdRegTS" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSideTrdRegTS'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSideTrdRegTS(FIX::NoSideTrdRegTS *arg1) {
    delete arg1;
}

swig_class cText;

SWIGINTERN VALUE
_wrap_new_Text__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Text *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Text";
  
  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 ;
  FIX::Text *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Text";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Text" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Text" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Text'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Text(FIX::Text *arg1) {
    delete arg1;
}

swig_class cEncodedTextLen;

SWIGINTERN VALUE
_wrap_new_EncodedTextLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedTextLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedTextLen";
  
  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 ;
  FIX::EncodedTextLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedTextLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedTextLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedTextLen(FIX::EncodedTextLen *arg1) {
    delete arg1;
}

swig_class cListExecInstType;

SWIGINTERN VALUE
_wrap_new_ListExecInstType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListExecInstType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListExecInstType";
  
  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 ;
  FIX::ListExecInstType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListExecInstType";
  
  if ((argc < 1) || (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), "in method '" "FIX::ListExecInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListExecInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListExecInstType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListExecInstType(FIX::ListExecInstType *arg1) {
    delete arg1;
}

swig_class cSecondaryOrderID;

SWIGINTERN VALUE
_wrap_new_SecondaryOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryOrderID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryOrderID";
  
  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 ;
  FIX::SecondaryOrderID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryOrderID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryOrderID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryOrderID(FIX::SecondaryOrderID *arg1) {
    delete arg1;
}

swig_class cExecBroker;

SWIGINTERN VALUE
_wrap_new_ExecBroker__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecBroker *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecBroker";
  
  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 ;
  FIX::ExecBroker *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecBroker";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExecBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecBroker'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecBroker(FIX::ExecBroker *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskEncodedSecurityDescLen;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskEncodedSecurityDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  FIX::RelationshipRiskEncodedSecurityDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskEncodedSecurityDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::RelationshipRiskEncodedSecurityDescLen *)new FIX::RelationshipRiskEncodedSecurityDescLen((FIX::LENGTH const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskEncodedSecurityDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskEncodedSecurityDescLen__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_RelationshipRiskEncodedSecurityDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskEncodedSecurityDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskEncodedSecurityDescLen(FIX::RelationshipRiskEncodedSecurityDescLen *arg1) {
    delete arg1;
}

swig_class cSecurityXMLLen;

SWIGINTERN VALUE
_wrap_new_SecurityXMLLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityXMLLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLLen";
  
  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 ;
  FIX::SecurityXMLLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityXMLLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityXMLLen(FIX::SecurityXMLLen *arg1) {
    delete arg1;
}

swig_class cApplSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplSeqNum";
  
  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 ;
  FIX::ApplSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::ApplSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplSeqNum(FIX::ApplSeqNum *arg1) {
    delete arg1;
}

swig_class cMaxTradeVol;

SWIGINTERN VALUE
_wrap_new_MaxTradeVol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaxTradeVol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxTradeVol";
  
  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 ;
  FIX::MaxTradeVol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxTradeVol";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaxTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaxTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaxTradeVol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxTradeVol(FIX::MaxTradeVol *arg1) {
    delete arg1;
}

swig_class cOfferSwapPoints;

SWIGINTERN VALUE
_wrap_new_OfferSwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OfferSwapPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSwapPoints";
  
  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 ;
  FIX::OfferSwapPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSwapPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::OfferSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OfferSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OfferSwapPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferSwapPoints(FIX::OfferSwapPoints *arg1) {
    delete arg1;
}

swig_class cSettlPartySubIDType;

SWIGINTERN VALUE
_wrap_new_SettlPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlPartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubIDType";
  
  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 ;
  FIX::SettlPartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartySubIDType(FIX::SettlPartySubIDType *arg1) {
    delete arg1;
}

swig_class cDistribPaymentMethod;

SWIGINTERN VALUE
_wrap_new_DistribPaymentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DistribPaymentMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DistribPaymentMethod";
  
  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 ;
  FIX::DistribPaymentMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DistribPaymentMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DistribPaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DistribPaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DistribPaymentMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DistribPaymentMethod(FIX::DistribPaymentMethod *arg1) {
    delete arg1;
}

swig_class cTotalAffectedOrders;

SWIGINTERN VALUE
_wrap_new_TotalAffectedOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalAffectedOrders *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalAffectedOrders";
  
  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 ;
  FIX::TotalAffectedOrders *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalAffectedOrders";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotalAffectedOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalAffectedOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalAffectedOrders'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalAffectedOrders(FIX::TotalAffectedOrders *arg1) {
    delete arg1;
}

swig_class cStrikeIncrement;

SWIGINTERN VALUE
_wrap_new_StrikeIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikeIncrement *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeIncrement";
  
  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 ;
  FIX::StrikeIncrement *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeIncrement";
  
  if ((argc < 1) || (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), "in method '" "FIX::StrikeIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikeIncrement'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeIncrement(FIX::StrikeIncrement *arg1) {
    delete arg1;
}

swig_class cOrderHandlingInstSource;

SWIGINTERN VALUE
_wrap_new_OrderHandlingInstSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderHandlingInstSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderHandlingInstSource";
  
  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 ;
  FIX::OrderHandlingInstSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderHandlingInstSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrderHandlingInstSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderHandlingInstSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderHandlingInstSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderHandlingInstSource(FIX::OrderHandlingInstSource *arg1) {
    delete arg1;
}

swig_class cCopyMsgIndicator;

SWIGINTERN VALUE
_wrap_new_CopyMsgIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CopyMsgIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CopyMsgIndicator";
  
  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 ;
  FIX::CopyMsgIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CopyMsgIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::CopyMsgIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CopyMsgIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CopyMsgIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CopyMsgIndicator(FIX::CopyMsgIndicator *arg1) {
    delete arg1;
}

swig_class cNoDlvyInst;

SWIGINTERN VALUE
_wrap_new_NoDlvyInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDlvyInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDlvyInst";
  
  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 ;
  FIX::NoDlvyInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDlvyInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoDlvyInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDlvyInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDlvyInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDlvyInst(FIX::NoDlvyInst *arg1) {
    delete arg1;
}

swig_class cQuoteEntryID;

SWIGINTERN VALUE
_wrap_new_QuoteEntryID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteEntryID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryID";
  
  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 ;
  FIX::QuoteEntryID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteEntryID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteEntryID(FIX::QuoteEntryID *arg1) {
    delete arg1;
}

swig_class cAffirmStatus;

SWIGINTERN VALUE
_wrap_new_AffirmStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AffirmStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffirmStatus";
  
  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 ;
  FIX::AffirmStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffirmStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AffirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AffirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AffirmStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AffirmStatus(FIX::AffirmStatus *arg1) {
    delete arg1;
}

swig_class cMailingInst;

SWIGINTERN VALUE
_wrap_new_MailingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MailingInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MailingInst";
  
  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 ;
  FIX::MailingInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MailingInst";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MailingInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MailingInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MailingInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MailingInst(FIX::MailingInst *arg1) {
    delete arg1;
}

swig_class cOfferSize;

SWIGINTERN VALUE
_wrap_new_OfferSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OfferSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSize";
  
  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 ;
  FIX::OfferSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::OfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OfferSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferSize(FIX::OfferSize *arg1) {
    delete arg1;
}

swig_class cLegSecurityType;

SWIGINTERN VALUE
_wrap_new_LegSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityType";
  
  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 ;
  FIX::LegSecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityType(FIX::LegSecurityType *arg1) {
    delete arg1;
}

swig_class cRiskLimitPlatform;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskLimitPlatform(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskLimitPlatform__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskLimitPlatform__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskLimitPlatform'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskLimitPlatform(FIX::RiskLimitPlatform *arg1) {
    delete arg1;
}

swig_class cOrigCustOrderCapacity;

SWIGINTERN VALUE
_wrap_new_OrigCustOrderCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigCustOrderCapacity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigCustOrderCapacity";
  
  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 ;
  FIX::OrigCustOrderCapacity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigCustOrderCapacity";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrigCustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigCustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigCustOrderCapacity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigCustOrderCapacity(FIX::OrigCustOrderCapacity *arg1) {
    delete arg1;
}

swig_class cAllocMethod;

SWIGINTERN VALUE
_wrap_new_AllocMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocMethod";
  
  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 ;
  FIX::AllocMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocMethod(FIX::AllocMethod *arg1) {
    delete arg1;
}

swig_class cQuantityDate;

SWIGINTERN VALUE
_wrap_new_QuantityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuantityDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuantityDate";
  
  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 ;
  FIX::QuantityDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuantityDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::QuantityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuantityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuantityDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuantityDate(FIX::QuantityDate *arg1) {
    delete arg1;
}

swig_class cTargetStrategyPerformance;

SWIGINTERN VALUE
_wrap_new_TargetStrategyPerformance__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetStrategyPerformance *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyPerformance";
  
  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 ;
  FIX::TargetStrategyPerformance *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyPerformance";
  
  if ((argc < 1) || (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), "in method '" "FIX::TargetStrategyPerformance" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetStrategyPerformance" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetStrategyPerformance'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetStrategyPerformance(FIX::TargetStrategyPerformance *arg1) {
    delete arg1;
}

swig_class cCardExpDate;

SWIGINTERN VALUE
_wrap_new_CardExpDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CardExpDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardExpDate";
  
  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 ;
  FIX::CardExpDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardExpDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::CardExpDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CardExpDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CardExpDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CardExpDate(FIX::CardExpDate *arg1) {
    delete arg1;
}

swig_class cConfirmID;

SWIGINTERN VALUE
_wrap_new_ConfirmID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ConfirmID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmID";
  
  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 ;
  FIX::ConfirmID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ConfirmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfirmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfirmID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmID(FIX::ConfirmID *arg1) {
    delete arg1;
}

swig_class cStandInstDbName;

SWIGINTERN VALUE
_wrap_new_StandInstDbName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StandInstDbName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbName";
  
  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 ;
  FIX::StandInstDbName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StandInstDbName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StandInstDbName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StandInstDbName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StandInstDbName(FIX::StandInstDbName *arg1) {
    delete arg1;
}

swig_class cDayOrderQty;

SWIGINTERN VALUE
_wrap_new_DayOrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DayOrderQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayOrderQty";
  
  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 ;
  FIX::DayOrderQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayOrderQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::DayOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DayOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DayOrderQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DayOrderQty(FIX::DayOrderQty *arg1) {
    delete arg1;
}

swig_class cHighLimitPrice;

SWIGINTERN VALUE
_wrap_new_HighLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HighLimitPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HighLimitPrice";
  
  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 ;
  FIX::HighLimitPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HighLimitPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::HighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HighLimitPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HighLimitPrice(FIX::HighLimitPrice *arg1) {
    delete arg1;
}

swig_class cFirmTradeID;

SWIGINTERN VALUE
_wrap_new_FirmTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FirmTradeID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FirmTradeID";
  
  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 ;
  FIX::FirmTradeID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FirmTradeID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::FirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FirmTradeID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FirmTradeID(FIX::FirmTradeID *arg1) {
    delete arg1;
}

swig_class cSecondaryIndividualAllocID;

SWIGINTERN VALUE
_wrap_new_SecondaryIndividualAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryIndividualAllocID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryIndividualAllocID";
  
  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 ;
  FIX::SecondaryIndividualAllocID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryIndividualAllocID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryIndividualAllocID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryIndividualAllocID(FIX::SecondaryIndividualAllocID *arg1) {
    delete arg1;
}

swig_class cAgreementDesc;

SWIGINTERN VALUE
_wrap_new_AgreementDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AgreementDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementDesc";
  
  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 ;
  FIX::AgreementDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AgreementDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AgreementDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AgreementDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementDesc(FIX::AgreementDesc *arg1) {
    delete arg1;
}

swig_class cMassCancelResponse;

SWIGINTERN VALUE
_wrap_new_MassCancelResponse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassCancelResponse *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelResponse";
  
  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 ;
  FIX::MassCancelResponse *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelResponse";
  
  if ((argc < 1) || (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), "in method '" "FIX::MassCancelResponse" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassCancelResponse" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassCancelResponse'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassCancelResponse(FIX::MassCancelResponse *arg1) {
    delete arg1;
}

swig_class cLegSettlCurrency;

SWIGINTERN VALUE
_wrap_new_LegSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSettlCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlCurrency";
  
  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 ;
  FIX::LegSettlCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSettlCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlCurrency(FIX::LegSettlCurrency *arg1) {
    delete arg1;
}

swig_class cCommission;

SWIGINTERN VALUE
_wrap_new_Commission__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Commission *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Commission";
  
  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 ;
  FIX::Commission *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Commission";
  
  if ((argc < 1) || (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), "in method '" "FIX::Commission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Commission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Commission'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Commission(FIX::Commission *arg1) {
    delete arg1;
}

swig_class cStreamAsgnReqType;

SWIGINTERN VALUE
_wrap_new_StreamAsgnReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StreamAsgnReqType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqType";
  
  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 ;
  FIX::StreamAsgnReqType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StreamAsgnReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StreamAsgnReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StreamAsgnReqType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnReqType(FIX::StreamAsgnReqType *arg1) {
    delete arg1;
}

swig_class cBidSwapPoints;

SWIGINTERN VALUE
_wrap_new_BidSwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidSwapPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSwapPoints";
  
  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 ;
  FIX::BidSwapPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSwapPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidSwapPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidSwapPoints(FIX::BidSwapPoints *arg1) {
    delete arg1;
}

swig_class cNoSettlPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoSettlPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSettlPartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartyIDs";
  
  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 ;
  FIX::NoSettlPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSettlPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSettlPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSettlPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlPartyIDs(FIX::NoSettlPartyIDs *arg1) {
    delete arg1;
}

swig_class cSymbolSfx;

SWIGINTERN VALUE
_wrap_new_SymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SymbolSfx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SymbolSfx";
  
  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 ;
  FIX::SymbolSfx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SymbolSfx";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SymbolSfx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SymbolSfx(FIX::SymbolSfx *arg1) {
    delete arg1;
}

swig_class cBusinessRejectRefID;

SWIGINTERN VALUE
_wrap_new_BusinessRejectRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BusinessRejectRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectRefID";
  
  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 ;
  FIX::BusinessRejectRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BusinessRejectRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BusinessRejectRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BusinessRejectRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BusinessRejectRefID(FIX::BusinessRejectRefID *arg1) {
    delete arg1;
}

swig_class cPrice2;

SWIGINTERN VALUE
_wrap_new_Price2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Price2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Price2";
  
  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 ;
  FIX::Price2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Price2";
  
  if ((argc < 1) || (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), "in method '" "FIX::Price2" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Price2" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Price2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Price2(FIX::Price2 *arg1) {
    delete arg1;
}

swig_class cFillLiquidityInd;

SWIGINTERN VALUE
_wrap_new_FillLiquidityInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FillLiquidityInd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillLiquidityInd";
  
  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 ;
  FIX::FillLiquidityInd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillLiquidityInd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::FillLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FillLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FillLiquidityInd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FillLiquidityInd(FIX::FillLiquidityInd *arg1) {
    delete arg1;
}

swig_class cMassActionReportID;

SWIGINTERN VALUE
_wrap_new_MassActionReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassActionReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionReportID";
  
  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 ;
  FIX::MassActionReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassActionReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassActionReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassActionReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionReportID(FIX::MassActionReportID *arg1) {
    delete arg1;
}

swig_class cDerivativeIssuer;

SWIGINTERN VALUE
_wrap_new_DerivativeIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeIssuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssuer";
  
  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 ;
  FIX::DerivativeIssuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssuer";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeIssuer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeIssuer(FIX::DerivativeIssuer *arg1) {
    delete arg1;
}

swig_class cExDestinationIDSource;

SWIGINTERN VALUE
_wrap_new_ExDestinationIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExDestinationIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDestinationIDSource";
  
  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 ;
  FIX::ExDestinationIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDestinationIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExDestinationIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExDestinationIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExDestinationIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExDestinationIDSource(FIX::ExDestinationIDSource *arg1) {
    delete arg1;
}

swig_class cCollRespID;

SWIGINTERN VALUE
_wrap_new_CollRespID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollRespID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollRespID";
  
  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 ;
  FIX::CollRespID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollRespID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollRespID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollRespID(FIX::CollRespID *arg1) {
    delete arg1;
}

swig_class cSecurityListRequestType;

SWIGINTERN VALUE
_wrap_new_SecurityListRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityListRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRequestType";
  
  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 ;
  FIX::SecurityListRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListRequestType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityListRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityListRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityListRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListRequestType(FIX::SecurityListRequestType *arg1) {
    delete arg1;
}

swig_class cEncodedLegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_EncodedLegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedLegSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDesc";
  
  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 ;
  FIX::EncodedLegSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedLegSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedLegSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedLegSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegSecurityDesc(FIX::EncodedLegSecurityDesc *arg1) {
    delete arg1;
}

swig_class cRelatedContextPartyRole;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedContextPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedContextPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedContextPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedContextPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedContextPartyRole(FIX::RelatedContextPartyRole *arg1) {
    delete arg1;
}

swig_class cUnderlyingSettlementStatus;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSettlementStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementStatus";
  
  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 ;
  FIX::UnderlyingSettlementStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSettlementStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSettlementStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSettlementStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlementStatus(FIX::UnderlyingSettlementStatus *arg1) {
    delete arg1;
}

swig_class cSecurityAltID;

SWIGINTERN VALUE
_wrap_new_SecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltID";
  
  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 ;
  FIX::SecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityAltID(FIX::SecurityAltID *arg1) {
    delete arg1;
}

swig_class cRegistRefID;

SWIGINTERN VALUE
_wrap_new_RegistRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRefID";
  
  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 ;
  FIX::RegistRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistRefID(FIX::RegistRefID *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskFlexibleIndicator;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskFlexibleIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::RelationshipRiskFlexibleIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskFlexibleIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::RelationshipRiskFlexibleIndicator *)new FIX::RelationshipRiskFlexibleIndicator((FIX::BOOLEAN const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskFlexibleIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskFlexibleIndicator__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_RelationshipRiskFlexibleIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskFlexibleIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskFlexibleIndicator(FIX::RelationshipRiskFlexibleIndicator *arg1) {
    delete arg1;
}

swig_class cDerivativePriceQuoteMethod;

SWIGINTERN VALUE
_wrap_new_DerivativePriceQuoteMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativePriceQuoteMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceQuoteMethod";
  
  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 ;
  FIX::DerivativePriceQuoteMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceQuoteMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativePriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativePriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativePriceQuoteMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePriceQuoteMethod(FIX::DerivativePriceQuoteMethod *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskProductComplex;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskProductComplex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskProductComplex__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskProductComplex__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskProductComplex'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskProductComplex(FIX::RelationshipRiskProductComplex *arg1) {
    delete arg1;
}

swig_class cOrderDelay;

SWIGINTERN VALUE
_wrap_new_OrderDelay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderDelay *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderDelay";
  
  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 ;
  FIX::OrderDelay *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderDelay";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrderDelay" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderDelay" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderDelay'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderDelay(FIX::OrderDelay *arg1) {
    delete arg1;
}

swig_class cNoNotAffectedOrders;

SWIGINTERN VALUE
_wrap_new_NoNotAffectedOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNotAffectedOrders *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNotAffectedOrders";
  
  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 ;
  FIX::NoNotAffectedOrders *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNotAffectedOrders";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNotAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNotAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNotAffectedOrders'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNotAffectedOrders(FIX::NoNotAffectedOrders *arg1) {
    delete arg1;
}

swig_class cNested3PartyID;

SWIGINTERN VALUE
_wrap_new_Nested3PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested3PartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyID";
  
  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 ;
  FIX::Nested3PartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested3PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested3PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested3PartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartyID(FIX::Nested3PartyID *arg1) {
    delete arg1;
}

swig_class cCollAsgnReason;

SWIGINTERN VALUE
_wrap_new_CollAsgnReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollAsgnReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnReason";
  
  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 ;
  FIX::CollAsgnReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollAsgnReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollAsgnReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollAsgnReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnReason(FIX::CollAsgnReason *arg1) {
    delete arg1;
}

swig_class cTotalVolumeTradedTime;

SWIGINTERN VALUE
_wrap_new_TotalVolumeTradedTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalVolumeTradedTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedTime";
  
  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 ;
  FIX::TotalVolumeTradedTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TotalVolumeTradedTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalVolumeTradedTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalVolumeTradedTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalVolumeTradedTime(FIX::TotalVolumeTradedTime *arg1) {
    delete arg1;
}

swig_class cSecurityExchange;

SWIGINTERN VALUE
_wrap_new_SecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityExchange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityExchange";
  
  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 ;
  FIX::SecurityExchange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityExchange";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityExchange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityExchange(FIX::SecurityExchange *arg1) {
    delete arg1;
}

swig_class cSettlPriceType;

SWIGINTERN VALUE
_wrap_new_SettlPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPriceType";
  
  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 ;
  FIX::SettlPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPriceType(FIX::SettlPriceType *arg1) {
    delete arg1;
}

swig_class cUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_UnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasureQty";
  
  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 ;
  FIX::UnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnitOfMeasureQty(FIX::UnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cUserRequestID;

SWIGINTERN VALUE
_wrap_new_UserRequestID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UserRequestID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserRequestID";
  
  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 ;
  FIX::UserRequestID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserRequestID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UserRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UserRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UserRequestID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UserRequestID(FIX::UserRequestID *arg1) {
    delete arg1;
}

swig_class cLastParPx;

SWIGINTERN VALUE
_wrap_new_LastParPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastParPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastParPx";
  
  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 ;
  FIX::LastParPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastParPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastParPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastParPx(FIX::LastParPx *arg1) {
    delete arg1;
}

swig_class cEndMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_EndMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EndMaturityMonthYear *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndMaturityMonthYear";
  
  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 ;
  FIX::EndMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::EndMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EndMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EndMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EndMaturityMonthYear(FIX::EndMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cDealingCapacity;

SWIGINTERN VALUE
_wrap_new_DealingCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DealingCapacity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DealingCapacity";
  
  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 ;
  FIX::DealingCapacity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DealingCapacity";
  
  if ((argc < 1) || (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), "in method '" "FIX::DealingCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DealingCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DealingCapacity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DealingCapacity(FIX::DealingCapacity *arg1) {
    delete arg1;
}

swig_class cPrevClosePx;

SWIGINTERN VALUE
_wrap_new_PrevClosePx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PrevClosePx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PrevClosePx";
  
  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 ;
  FIX::PrevClosePx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PrevClosePx";
  
  if ((argc < 1) || (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), "in method '" "FIX::PrevClosePx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PrevClosePx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PrevClosePx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PrevClosePx(FIX::PrevClosePx *arg1) {
    delete arg1;
}

swig_class cTradeInputDevice;

SWIGINTERN VALUE
_wrap_new_TradeInputDevice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeInputDevice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeInputDevice";
  
  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 ;
  FIX::TradeInputDevice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeInputDevice";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeInputDevice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeInputDevice(FIX::TradeInputDevice *arg1) {
    delete arg1;
}

swig_class cDayCumQty;

SWIGINTERN VALUE
_wrap_new_DayCumQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DayCumQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayCumQty";
  
  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 ;
  FIX::DayCumQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayCumQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::DayCumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DayCumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DayCumQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DayCumQty(FIX::DayCumQty *arg1) {
    delete arg1;
}

swig_class cSecuritySettlAgentAcctNum;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentAcctNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecuritySettlAgentAcctNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctNum";
  
  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 ;
  FIX::SecuritySettlAgentAcctNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctNum";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecuritySettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecuritySettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecuritySettlAgentAcctNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentAcctNum(FIX::SecuritySettlAgentAcctNum *arg1) {
    delete arg1;
}

swig_class cLegCurrency;

SWIGINTERN VALUE
_wrap_new_LegCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCurrency";
  
  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 ;
  FIX::LegCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCurrency(FIX::LegCurrency *arg1) {
    delete arg1;
}

swig_class cEncryptedNewPassword;

SWIGINTERN VALUE
_wrap_new_EncryptedNewPassword__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncryptedNewPassword *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPassword";
  
  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 ;
  FIX::EncryptedNewPassword *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPassword";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncryptedNewPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncryptedNewPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncryptedNewPassword'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedNewPassword(FIX::EncryptedNewPassword *arg1) {
    delete arg1;
}

swig_class cDerivativeMinPriceIncrementAmount;

SWIGINTERN VALUE
_wrap_new_DerivativeMinPriceIncrementAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeMinPriceIncrementAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrementAmount";
  
  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 ;
  FIX::DerivativeMinPriceIncrementAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrementAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeMinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeMinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeMinPriceIncrementAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMinPriceIncrementAmount(FIX::DerivativeMinPriceIncrementAmount *arg1) {
    delete arg1;
}

swig_class cNoNested3PartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNested3PartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNested3PartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartySubIDs";
  
  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 ;
  FIX::NoNested3PartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNested3PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNested3PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNested3PartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested3PartySubIDs(FIX::NoNested3PartySubIDs *arg1) {
    delete arg1;
}

swig_class cRefSubID;

SWIGINTERN VALUE
_wrap_new_RefSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefSubID";
  
  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 ;
  FIX::RefSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefSubID(FIX::RefSubID *arg1) {
    delete arg1;
}

swig_class cSettlPartyRole;

SWIGINTERN VALUE
_wrap_new_SettlPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyRole";
  
  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 ;
  FIX::SettlPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartyRole(FIX::SettlPartyRole *arg1) {
    delete arg1;
}

swig_class cCashDistribAgentName;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashDistribAgentName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentName";
  
  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 ;
  FIX::CashDistribAgentName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashDistribAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashDistribAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashDistribAgentName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentName(FIX::CashDistribAgentName *arg1) {
    delete arg1;
}

swig_class cLegContractMultiplier;

SWIGINTERN VALUE
_wrap_new_LegContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegContractMultiplier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplier";
  
  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 ;
  FIX::LegContractMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegContractMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegContractMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegContractMultiplier(FIX::LegContractMultiplier *arg1) {
    delete arg1;
}

swig_class cProgPeriodInterval;

SWIGINTERN VALUE
_wrap_new_ProgPeriodInterval__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ProgPeriodInterval *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProgPeriodInterval";
  
  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 ;
  FIX::ProgPeriodInterval *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProgPeriodInterval";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ProgPeriodInterval" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ProgPeriodInterval" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ProgPeriodInterval'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ProgPeriodInterval(FIX::ProgPeriodInterval *arg1) {
    delete arg1;
}

swig_class cLegSettlType;

SWIGINTERN VALUE
_wrap_new_LegSettlType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSettlType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlType";
  
  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 ;
  FIX::LegSettlType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlType";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegSettlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSettlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSettlType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlType(FIX::LegSettlType *arg1) {
    delete arg1;
}

swig_class cOnBehalfOfLocationID;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OnBehalfOfLocationID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfLocationID";
  
  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 ;
  FIX::OnBehalfOfLocationID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfLocationID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OnBehalfOfLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OnBehalfOfLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OnBehalfOfLocationID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfLocationID(FIX::OnBehalfOfLocationID *arg1) {
    delete arg1;
}

swig_class cOnBehalfOfSubID;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OnBehalfOfSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSubID";
  
  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 ;
  FIX::OnBehalfOfSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OnBehalfOfSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OnBehalfOfSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OnBehalfOfSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfSubID(FIX::OnBehalfOfSubID *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskLimitPlatform;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskLimitPlatform(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskLimitPlatform__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskLimitPlatform__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskLimitPlatform'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskLimitPlatform(FIX::RelationshipRiskLimitPlatform *arg1) {
    delete arg1;
}

swig_class cRelatedPartySubID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartySubID(FIX::RelatedPartySubID *arg1) {
    delete arg1;
}

swig_class cComplexEventEndTime;

SWIGINTERN VALUE
_wrap_new_ComplexEventEndTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventEndTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndTime";
  
  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 ;
  FIX::ComplexEventEndTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::ComplexEventEndTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventEndTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventEndTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventEndTime(FIX::ComplexEventEndTime *arg1) {
    delete arg1;
}

swig_class cRateSourceType;

SWIGINTERN VALUE
_wrap_new_RateSourceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RateSourceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RateSourceType";
  
  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 ;
  FIX::RateSourceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RateSourceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RateSourceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RateSourceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RateSourceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RateSourceType(FIX::RateSourceType *arg1) {
    delete arg1;
}

swig_class cDerivativeStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeStateOrProvinceOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStateOrProvinceOfIssue";
  
  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 ;
  FIX::DerivativeStateOrProvinceOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStateOrProvinceOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeStateOrProvinceOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStateOrProvinceOfIssue(FIX::DerivativeStateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class cTradeLegRefID;

SWIGINTERN VALUE
_wrap_new_TradeLegRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeLegRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeLegRefID";
  
  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 ;
  FIX::TradeLegRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeLegRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeLegRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeLegRefID(FIX::TradeLegRefID *arg1) {
    delete arg1;
}

swig_class cRelSymTransactTime;

SWIGINTERN VALUE
_wrap_new_RelSymTransactTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RelSymTransactTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  
  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 ;
  FIX::RelSymTransactTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  
  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), "in method '" "FIX::RelSymTransactTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::RelSymTransactTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::RelSymTransactTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelSymTransactTime";
  
  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), "in method '" "FIX::RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::RelSymTransactTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelSymTransactTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelSymTransactTime(FIX::RelSymTransactTime *arg1) {
    delete arg1;
}

swig_class cNoComplexEventTimes;

SWIGINTERN VALUE
_wrap_new_NoComplexEventTimes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoComplexEventTimes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventTimes";
  
  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 ;
  FIX::NoComplexEventTimes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventTimes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoComplexEventTimes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoComplexEventTimes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoComplexEventTimes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoComplexEventTimes(FIX::NoComplexEventTimes *arg1) {
    delete arg1;
}

swig_class cLegCalculatedCcyLastQty;

SWIGINTERN VALUE
_wrap_new_LegCalculatedCcyLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCalculatedCcyLastQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCalculatedCcyLastQty";
  
  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 ;
  FIX::LegCalculatedCcyLastQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCalculatedCcyLastQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegCalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCalculatedCcyLastQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCalculatedCcyLastQty(FIX::LegCalculatedCcyLastQty *arg1) {
    delete arg1;
}

swig_class cNested3PartyIDSource;

SWIGINTERN VALUE
_wrap_new_Nested3PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested3PartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyIDSource";
  
  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 ;
  FIX::Nested3PartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::Nested3PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested3PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested3PartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartyIDSource(FIX::Nested3PartyIDSource *arg1) {
    delete arg1;
}

swig_class cDatedDate;

SWIGINTERN VALUE
_wrap_new_DatedDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DatedDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DatedDate";
  
  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 ;
  FIX::DatedDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DatedDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::DatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DatedDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DatedDate(FIX::DatedDate *arg1) {
    delete arg1;
}

swig_class cSettlInstID;

SWIGINTERN VALUE
_wrap_new_SettlInstID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstID";
  
  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 ;
  FIX::SettlInstID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlInstID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstID(FIX::SettlInstID *arg1) {
    delete arg1;
}

swig_class cOpenInterest;

SWIGINTERN VALUE
_wrap_new_OpenInterest__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OpenInterest *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenInterest";
  
  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 ;
  FIX::OpenInterest *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenInterest";
  
  if ((argc < 1) || (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), "in method '" "FIX::OpenInterest" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OpenInterest" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OpenInterest'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenInterest(FIX::OpenInterest *arg1) {
    delete arg1;
}

swig_class cUnderlyingContractMultiplier;

SWIGINTERN VALUE
_wrap_new_UnderlyingContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingContractMultiplier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplier";
  
  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 ;
  FIX::UnderlyingContractMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingContractMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingContractMultiplier(FIX::UnderlyingContractMultiplier *arg1) {
    delete arg1;
}

swig_class cTotQuoteEntries;

SWIGINTERN VALUE
_wrap_new_TotQuoteEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotQuoteEntries *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotQuoteEntries";
  
  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 ;
  FIX::TotQuoteEntries *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotQuoteEntries";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotQuoteEntries'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotQuoteEntries(FIX::TotQuoteEntries *arg1) {
    delete arg1;
}

swig_class cPartyAltSubID;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyAltSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyAltSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyAltSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyAltSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyAltSubID(FIX::PartyAltSubID *arg1) {
    delete arg1;
}

swig_class cTotNoCxldQuotes;

SWIGINTERN VALUE
_wrap_new_TotNoCxldQuotes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoCxldQuotes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoCxldQuotes";
  
  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 ;
  FIX::TotNoCxldQuotes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoCxldQuotes";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoCxldQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoCxldQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoCxldQuotes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoCxldQuotes(FIX::TotNoCxldQuotes *arg1) {
    delete arg1;
}

swig_class cAggregatedBook;

SWIGINTERN VALUE
_wrap_new_AggregatedBook__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AggregatedBook *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AggregatedBook";
  
  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 ;
  FIX::AggregatedBook *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AggregatedBook";
  
  if ((argc < 1) || (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), "in method '" "FIX::AggregatedBook" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AggregatedBook" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AggregatedBook'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AggregatedBook(FIX::AggregatedBook *arg1) {
    delete arg1;
}

swig_class cPaymentRef;

SWIGINTERN VALUE
_wrap_new_PaymentRef__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PaymentRef *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentRef";
  
  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 ;
  FIX::PaymentRef *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentRef";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PaymentRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PaymentRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PaymentRef'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentRef(FIX::PaymentRef *arg1) {
    delete arg1;
}

swig_class cPaymentDate;

SWIGINTERN VALUE
_wrap_new_PaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PaymentDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentDate";
  
  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 ;
  FIX::PaymentDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::PaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PaymentDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentDate(FIX::PaymentDate *arg1) {
    delete arg1;
}

swig_class cOrderPercent;

SWIGINTERN VALUE
_wrap_new_OrderPercent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderPercent *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderPercent";
  
  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 ;
  FIX::OrderPercent *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderPercent";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderPercent'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderPercent(FIX::OrderPercent *arg1) {
    delete arg1;
}

swig_class cPosQtyStatus;

SWIGINTERN VALUE
_wrap_new_PosQtyStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosQtyStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosQtyStatus";
  
  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 ;
  FIX::PosQtyStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosQtyStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosQtyStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosQtyStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosQtyStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosQtyStatus(FIX::PosQtyStatus *arg1) {
    delete arg1;
}

swig_class cRiskRestructuringType;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskRestructuringType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskRestructuringType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskRestructuringType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskRestructuringType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskRestructuringType(FIX::RiskRestructuringType *arg1) {
    delete arg1;
}

swig_class cNoNested4PartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNested4PartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNested4PartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartySubIDs";
  
  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 ;
  FIX::NoNested4PartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNested4PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNested4PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNested4PartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested4PartySubIDs(FIX::NoNested4PartySubIDs *arg1) {
    delete arg1;
}

swig_class cPrivateQuote;

SWIGINTERN VALUE
_wrap_new_PrivateQuote__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PrivateQuote *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PrivateQuote";
  
  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 ;
  FIX::PrivateQuote *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PrivateQuote";
  
  if ((argc < 1) || (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), "in method '" "FIX::PrivateQuote" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PrivateQuote" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PrivateQuote'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PrivateQuote(FIX::PrivateQuote *arg1) {
    delete arg1;
}

swig_class cSecondaryTradeID;

SWIGINTERN VALUE
_wrap_new_SecondaryTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryTradeID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeID";
  
  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 ;
  FIX::SecondaryTradeID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryTradeID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradeID(FIX::SecondaryTradeID *arg1) {
    delete arg1;
}

swig_class cSecuritySettlAgentContactPhone;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentContactPhone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecuritySettlAgentContactPhone *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactPhone";
  
  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 ;
  FIX::SecuritySettlAgentContactPhone *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactPhone";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecuritySettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecuritySettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecuritySettlAgentContactPhone'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentContactPhone(FIX::SecuritySettlAgentContactPhone *arg1) {
    delete arg1;
}

swig_class cEncodedMktSegmDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedMktSegmDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedMktSegmDescLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDescLen";
  
  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 ;
  FIX::EncodedMktSegmDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedMktSegmDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedMktSegmDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedMktSegmDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedMktSegmDescLen(FIX::EncodedMktSegmDescLen *arg1) {
    delete arg1;
}

swig_class cSideCurrency;

SWIGINTERN VALUE
_wrap_new_SideCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideCurrency";
  
  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 ;
  FIX::SideCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::SideCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideCurrency(FIX::SideCurrency *arg1) {
    delete arg1;
}

swig_class cLegQty;

SWIGINTERN VALUE
_wrap_new_LegQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegQty";
  
  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 ;
  FIX::LegQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegQty(FIX::LegQty *arg1) {
    delete arg1;
}

swig_class cMsgType;

SWIGINTERN VALUE
_wrap_new_MsgType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MsgType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgType";
  
  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 ;
  FIX::MsgType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MsgType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MsgType(FIX::MsgType *arg1) {
    delete arg1;
}

swig_class cNoTradingSessions;

SWIGINTERN VALUE
_wrap_new_NoTradingSessions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTradingSessions *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessions";
  
  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 ;
  FIX::NoTradingSessions *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessions";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTradingSessions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTradingSessions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTradingSessions'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTradingSessions(FIX::NoTradingSessions *arg1) {
    delete arg1;
}

swig_class cIOIid;

SWIGINTERN VALUE
_wrap_new_IOIid__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIid *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIid";
  
  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 ;
  FIX::IOIid *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIid";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IOIid" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIid" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIid'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIid(FIX::IOIid *arg1) {
    delete arg1;
}

swig_class cMultiLegReportingType;

SWIGINTERN VALUE
_wrap_new_MultiLegReportingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MultiLegReportingType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultiLegReportingType";
  
  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 ;
  FIX::MultiLegReportingType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultiLegReportingType";
  
  if ((argc < 1) || (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), "in method '" "FIX::MultiLegReportingType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MultiLegReportingType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MultiLegReportingType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MultiLegReportingType(FIX::MultiLegReportingType *arg1) {
    delete arg1;
}

swig_class cIDSource;

SWIGINTERN VALUE
_wrap_new_IDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IDSource";
  
  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 ;
  FIX::IDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IDSource(FIX::IDSource *arg1) {
    delete arg1;
}

swig_class cLegStipulationType;

SWIGINTERN VALUE
_wrap_new_LegStipulationType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegStipulationType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationType";
  
  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 ;
  FIX::LegStipulationType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegStipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegStipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegStipulationType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStipulationType(FIX::LegStipulationType *arg1) {
    delete arg1;
}

swig_class cDerivativeContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_DerivativeContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeContractMultiplierUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplierUnit";
  
  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 ;
  FIX::DerivativeContractMultiplierUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplierUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeContractMultiplierUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeContractMultiplierUnit(FIX::DerivativeContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class cMarketSegmentID;

SWIGINTERN VALUE
_wrap_new_MarketSegmentID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarketSegmentID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentID";
  
  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 ;
  FIX::MarketSegmentID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketSegmentID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MarketSegmentID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarketSegmentID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarketSegmentID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketSegmentID(FIX::MarketSegmentID *arg1) {
    delete arg1;
}

swig_class cOrdStatus;

SWIGINTERN VALUE
_wrap_new_OrdStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrdStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdStatus";
  
  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 ;
  FIX::OrdStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdStatus";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrdStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrdStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrdStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdStatus(FIX::OrdStatus *arg1) {
    delete arg1;
}

swig_class cMaturityDate;

SWIGINTERN VALUE
_wrap_new_MaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityDate";
  
  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 ;
  FIX::MaturityDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityDate(FIX::MaturityDate *arg1) {
    delete arg1;
}

swig_class cApplTotalMessageCount;

SWIGINTERN VALUE
_wrap_new_ApplTotalMessageCount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplTotalMessageCount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplTotalMessageCount";
  
  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 ;
  FIX::ApplTotalMessageCount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplTotalMessageCount";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplTotalMessageCount" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplTotalMessageCount" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplTotalMessageCount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplTotalMessageCount(FIX::ApplTotalMessageCount *arg1) {
    delete arg1;
}

swig_class cInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_InstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrumentPartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubID";
  
  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 ;
  FIX::InstrumentPartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrumentPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartySubID(FIX::InstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class cCustomerOrFirm;

SWIGINTERN VALUE
_wrap_new_CustomerOrFirm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CustomerOrFirm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustomerOrFirm";
  
  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 ;
  FIX::CustomerOrFirm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustomerOrFirm";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CustomerOrFirm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CustomerOrFirm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CustomerOrFirm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CustomerOrFirm(FIX::CustomerOrFirm *arg1) {
    delete arg1;
}

swig_class cAdjustmentType;

SWIGINTERN VALUE
_wrap_new_AdjustmentType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AdjustmentType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdjustmentType";
  
  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 ;
  FIX::AdjustmentType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdjustmentType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AdjustmentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AdjustmentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AdjustmentType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AdjustmentType(FIX::AdjustmentType *arg1) {
    delete arg1;
}

swig_class cNoPartyAltSubIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoPartyAltSubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyAltSubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyAltSubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPartyAltSubIDs *)new FIX::NoPartyAltSubIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPartyAltSubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPartyAltSubIDs__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_NoPartyAltSubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPartyAltSubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartyAltSubIDs(FIX::NoPartyAltSubIDs *arg1) {
    delete arg1;
}

swig_class cUnderlyingInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingInstrumentPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyID";
  
  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 ;
  FIX::UnderlyingInstrumentPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingInstrumentPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartyID(FIX::UnderlyingInstrumentPartyID *arg1) {
    delete arg1;
}

swig_class cAsOfIndicator;

SWIGINTERN VALUE
_wrap_new_AsOfIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AsOfIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AsOfIndicator";
  
  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 ;
  FIX::AsOfIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AsOfIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::AsOfIndicator" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AsOfIndicator" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AsOfIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AsOfIndicator(FIX::AsOfIndicator *arg1) {
    delete arg1;
}

swig_class cQuoteStatusReqID;

SWIGINTERN VALUE
_wrap_new_QuoteStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteStatusReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatusReqID";
  
  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 ;
  FIX::QuoteStatusReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatusReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteStatusReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteStatusReqID(FIX::QuoteStatusReqID *arg1) {
    delete arg1;
}

swig_class cLegPositionEffect;

SWIGINTERN VALUE
_wrap_new_LegPositionEffect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegPositionEffect *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPositionEffect";
  
  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 ;
  FIX::LegPositionEffect *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPositionEffect";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegPositionEffect'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPositionEffect(FIX::LegPositionEffect *arg1) {
    delete arg1;
}

swig_class cMDEntryPx;

SWIGINTERN VALUE
_wrap_new_MDEntryPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPx";
  
  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 ;
  FIX::MDEntryPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDEntryPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryPx(FIX::MDEntryPx *arg1) {
    delete arg1;
}

swig_class cMassActionScope;

SWIGINTERN VALUE
_wrap_new_MassActionScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassActionScope *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionScope";
  
  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 ;
  FIX::MassActionScope *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionScope";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassActionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassActionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassActionScope'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionScope(FIX::MassActionScope *arg1) {
    delete arg1;
}

swig_class cReportedPxDiff;

SWIGINTERN VALUE
_wrap_new_ReportedPxDiff__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ReportedPxDiff *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportedPxDiff";
  
  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 ;
  FIX::ReportedPxDiff *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportedPxDiff";
  
  if ((argc < 1) || (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), "in method '" "FIX::ReportedPxDiff" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ReportedPxDiff" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ReportedPxDiff'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ReportedPxDiff(FIX::ReportedPxDiff *arg1) {
    delete arg1;
}

swig_class cUnderlyingSettlementDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSettlementDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementDate";
  
  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 ;
  FIX::UnderlyingSettlementDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingSettlementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSettlementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSettlementDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlementDate(FIX::UnderlyingSettlementDate *arg1) {
    delete arg1;
}

swig_class cNoNestedPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNestedPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNestedPartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartySubIDs";
  
  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 ;
  FIX::NoNestedPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNestedPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNestedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNestedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNestedPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNestedPartySubIDs(FIX::NoNestedPartySubIDs *arg1) {
    delete arg1;
}

swig_class cAllocReportRefID;

SWIGINTERN VALUE
_wrap_new_AllocReportRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocReportRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportRefID";
  
  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 ;
  FIX::AllocReportRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocReportRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocReportRefID(FIX::AllocReportRefID *arg1) {
    delete arg1;
}

swig_class cConcession;

SWIGINTERN VALUE
_wrap_new_Concession__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Concession *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Concession";
  
  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 ;
  FIX::Concession *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Concession";
  
  if ((argc < 1) || (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), "in method '" "FIX::Concession" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Concession" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Concession'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Concession(FIX::Concession *arg1) {
    delete arg1;
}

swig_class cEncodedSecurityDesc;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDesc";
  
  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 ;
  FIX::EncodedSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityDesc(FIX::EncodedSecurityDesc *arg1) {
    delete arg1;
}

swig_class cExecRefID;

SWIGINTERN VALUE
_wrap_new_ExecRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecRefID";
  
  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 ;
  FIX::ExecRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExecRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecRefID(FIX::ExecRefID *arg1) {
    delete arg1;
}

swig_class cVenueType;

SWIGINTERN VALUE
_wrap_new_VenueType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::VenueType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::VenueType";
  
  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 ;
  FIX::VenueType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::VenueType";
  
  if ((argc < 1) || (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), "in method '" "FIX::VenueType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::VenueType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_VenueType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_VenueType(FIX::VenueType *arg1) {
    delete arg1;
}

swig_class cMassActionType;

SWIGINTERN VALUE
_wrap_new_MassActionType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassActionType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionType";
  
  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 ;
  FIX::MassActionType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassActionType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassActionType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassActionType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionType(FIX::MassActionType *arg1) {
    delete arg1;
}

swig_class cPosMaintResult;

SWIGINTERN VALUE
_wrap_new_PosMaintResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosMaintResult *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintResult";
  
  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 ;
  FIX::PosMaintResult *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintResult";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosMaintResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosMaintResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosMaintResult'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintResult(FIX::PosMaintResult *arg1) {
    delete arg1;
}

swig_class cIOIShares;

SWIGINTERN VALUE
_wrap_new_IOIShares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIShares *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIShares";
  
  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 ;
  FIX::IOIShares *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIShares";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IOIShares" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIShares" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIShares'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIShares(FIX::IOIShares *arg1) {
    delete arg1;
}

swig_class cBenchmarkSecurityID;

SWIGINTERN VALUE
_wrap_new_BenchmarkSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BenchmarkSecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityID";
  
  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 ;
  FIX::BenchmarkSecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkSecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BenchmarkSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BenchmarkSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BenchmarkSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkSecurityID(FIX::BenchmarkSecurityID *arg1) {
    delete arg1;
}

swig_class cLegLastQty;

SWIGINTERN VALUE
_wrap_new_LegLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegLastQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastQty";
  
  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 ;
  FIX::LegLastQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegLastQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLastQty(FIX::LegLastQty *arg1) {
    delete arg1;
}

swig_class cAllocSettlCurrency;

SWIGINTERN VALUE
_wrap_new_AllocSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocSettlCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrency";
  
  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 ;
  FIX::AllocSettlCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocSettlCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocSettlCurrency(FIX::AllocSettlCurrency *arg1) {
    delete arg1;
}

swig_class cLegCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_LegCountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCountryOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCountryOfIssue";
  
  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 ;
  FIX::LegCountryOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCountryOfIssue";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCountryOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCountryOfIssue(FIX::LegCountryOfIssue *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityXML;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXML__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityXML *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXML";
  
  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 ;
  FIX::DerivativeSecurityXML *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXML";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeSecurityXML" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityXML" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityXML'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityXML(FIX::DerivativeSecurityXML *arg1) {
    delete arg1;
}

swig_class cStrikeRuleID;

SWIGINTERN VALUE
_wrap_new_StrikeRuleID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikeRuleID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeRuleID";
  
  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 ;
  FIX::StrikeRuleID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeRuleID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StrikeRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikeRuleID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeRuleID(FIX::StrikeRuleID *arg1) {
    delete arg1;
}

swig_class cRefCompID;

SWIGINTERN VALUE
_wrap_new_RefCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefCompID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefCompID";
  
  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 ;
  FIX::RefCompID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefCompID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefCompID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefCompID(FIX::RefCompID *arg1) {
    delete arg1;
}

swig_class cSettlCurrOfferFxRate;

SWIGINTERN VALUE
_wrap_new_SettlCurrOfferFxRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlCurrOfferFxRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrOfferFxRate";
  
  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 ;
  FIX::SettlCurrOfferFxRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrOfferFxRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlCurrOfferFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlCurrOfferFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlCurrOfferFxRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrOfferFxRate(FIX::SettlCurrOfferFxRate *arg1) {
    delete arg1;
}

swig_class cOfferYield;

SWIGINTERN VALUE
_wrap_new_OfferYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OfferYield *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferYield";
  
  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 ;
  FIX::OfferYield *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferYield";
  
  if ((argc < 1) || (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), "in method '" "FIX::OfferYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OfferYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OfferYield'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferYield(FIX::OfferYield *arg1) {
    delete arg1;
}

swig_class cRelatedContextPartyID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedContextPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedContextPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedContextPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedContextPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedContextPartyID(FIX::RelatedContextPartyID *arg1) {
    delete arg1;
}

swig_class cTargetPartyIDSource;

SWIGINTERN VALUE
_wrap_new_TargetPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyIDSource";
  
  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 ;
  FIX::TargetPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::TargetPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetPartyIDSource(FIX::TargetPartyIDSource *arg1) {
    delete arg1;
}

swig_class cEncryptedNewPasswordLen;

SWIGINTERN VALUE
_wrap_new_EncryptedNewPasswordLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncryptedNewPasswordLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPasswordLen";
  
  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 ;
  FIX::EncryptedNewPasswordLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedNewPasswordLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncryptedNewPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncryptedNewPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncryptedNewPasswordLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedNewPasswordLen(FIX::EncryptedNewPasswordLen *arg1) {
    delete arg1;
}

swig_class cNoPositions;

SWIGINTERN VALUE
_wrap_new_NoPositions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoPositions *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPositions";
  
  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 ;
  FIX::NoPositions *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPositions";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPositions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPositions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPositions'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPositions(FIX::NoPositions *arg1) {
    delete arg1;
}

swig_class cTotalAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_TotalAccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalAccruedInterestAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalAccruedInterestAmt";
  
  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 ;
  FIX::TotalAccruedInterestAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalAccruedInterestAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::TotalAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalAccruedInterestAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalAccruedInterestAmt(FIX::TotalAccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class cUnderlyingOptAttribute;

SWIGINTERN VALUE
_wrap_new_UnderlyingOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingOptAttribute *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOptAttribute";
  
  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 ;
  FIX::UnderlyingOptAttribute *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingOptAttribute";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingOptAttribute'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingOptAttribute(FIX::UnderlyingOptAttribute *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrAttribValue;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrAttribValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrAttribValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribValue";
  
  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 ;
  FIX::DerivativeInstrAttribValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrAttribValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrAttribValue(FIX::DerivativeInstrAttribValue *arg1) {
    delete arg1;
}

swig_class cInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_InstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrumentPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyIDSource";
  
  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 ;
  FIX::InstrumentPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::InstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrumentPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartyIDSource(FIX::InstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class cPegOffsetType;

SWIGINTERN VALUE
_wrap_new_PegOffsetType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegOffsetType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetType";
  
  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 ;
  FIX::PegOffsetType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegOffsetType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegOffsetType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegOffsetType(FIX::PegOffsetType *arg1) {
    delete arg1;
}

swig_class cMassCancelRejectReason;

SWIGINTERN VALUE
_wrap_new_MassCancelRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassCancelRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRejectReason";
  
  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 ;
  FIX::MassCancelRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassCancelRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassCancelRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassCancelRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassCancelRejectReason(FIX::MassCancelRejectReason *arg1) {
    delete arg1;
}

swig_class cResponseTransportType;

SWIGINTERN VALUE
_wrap_new_ResponseTransportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ResponseTransportType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResponseTransportType";
  
  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 ;
  FIX::ResponseTransportType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResponseTransportType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ResponseTransportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ResponseTransportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ResponseTransportType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ResponseTransportType(FIX::ResponseTransportType *arg1) {
    delete arg1;
}

swig_class cLegSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_LegSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityIDSource";
  
  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 ;
  FIX::LegSecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityIDSource(FIX::LegSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cBasisFeaturePrice;

SWIGINTERN VALUE
_wrap_new_BasisFeaturePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BasisFeaturePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisFeaturePrice";
  
  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 ;
  FIX::BasisFeaturePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisFeaturePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::BasisFeaturePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BasisFeaturePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BasisFeaturePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BasisFeaturePrice(FIX::BasisFeaturePrice *arg1) {
    delete arg1;
}

swig_class cCouponPaymentDate;

SWIGINTERN VALUE
_wrap_new_CouponPaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CouponPaymentDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CouponPaymentDate";
  
  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 ;
  FIX::CouponPaymentDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CouponPaymentDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::CouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CouponPaymentDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CouponPaymentDate(FIX::CouponPaymentDate *arg1) {
    delete arg1;
}

swig_class cTradSesStatusRejReason;

SWIGINTERN VALUE
_wrap_new_TradSesStatusRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesStatusRejReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatusRejReason";
  
  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 ;
  FIX::TradSesStatusRejReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStatusRejReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradSesStatusRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesStatusRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesStatusRejReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesStatusRejReason(FIX::TradSesStatusRejReason *arg1) {
    delete arg1;
}

swig_class cUnderlyingDetachmentPoint;

SWIGINTERN VALUE
_wrap_new_UnderlyingDetachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingDetachmentPoint *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDetachmentPoint";
  
  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 ;
  FIX::UnderlyingDetachmentPoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDetachmentPoint";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingDetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingDetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingDetachmentPoint'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingDetachmentPoint(FIX::UnderlyingDetachmentPoint *arg1) {
    delete arg1;
}

swig_class cMaturityRuleID;

SWIGINTERN VALUE
_wrap_new_MaturityRuleID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityRuleID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityRuleID";
  
  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 ;
  FIX::MaturityRuleID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityRuleID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MaturityRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityRuleID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityRuleID(FIX::MaturityRuleID *arg1) {
    delete arg1;
}

swig_class cUnderlyingRepoCollateralSecurityType;

SWIGINTERN VALUE
_wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingRepoCollateralSecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepoCollateralSecurityType";
  
  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::INT *arg1 = 0 ;
  FIX::UnderlyingRepoCollateralSecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepoCollateralSecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::UnderlyingRepoCollateralSecurityType *)new FIX::UnderlyingRepoCollateralSecurityType((FIX::INT 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__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingRepoCollateralSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRepoCollateralSecurityType(FIX::UnderlyingRepoCollateralSecurityType *arg1) {
    delete arg1;
}

swig_class cNoTimeInForceRules;

SWIGINTERN VALUE
_wrap_new_NoTimeInForceRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTimeInForceRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTimeInForceRules";
  
  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 ;
  FIX::NoTimeInForceRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTimeInForceRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTimeInForceRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTimeInForceRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTimeInForceRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTimeInForceRules(FIX::NoTimeInForceRules *arg1) {
    delete arg1;
}

swig_class cNoRootPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoRootPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoRootPartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartySubIDs";
  
  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 ;
  FIX::NoRootPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRootPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRootPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRootPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRootPartySubIDs(FIX::NoRootPartySubIDs *arg1) {
    delete arg1;
}

swig_class cDisplayMinIncr;

SWIGINTERN VALUE
_wrap_new_DisplayMinIncr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DisplayMinIncr *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayMinIncr";
  
  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 ;
  FIX::DisplayMinIncr *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayMinIncr";
  
  if ((argc < 1) || (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), "in method '" "FIX::DisplayMinIncr" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DisplayMinIncr" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DisplayMinIncr'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayMinIncr(FIX::DisplayMinIncr *arg1) {
    delete arg1;
}

swig_class cTrdRegTimestampType;

SWIGINTERN VALUE
_wrap_new_TrdRegTimestampType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdRegTimestampType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampType";
  
  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 ;
  FIX::TrdRegTimestampType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdRegTimestampType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRegTimestampType(FIX::TrdRegTimestampType *arg1) {
    delete arg1;
}

swig_class cLegProduct;

SWIGINTERN VALUE
_wrap_new_LegProduct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegProduct *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegProduct";
  
  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 ;
  FIX::LegProduct *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegProduct";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegProduct'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegProduct(FIX::LegProduct *arg1) {
    delete arg1;
}

swig_class cApplVerID;

SWIGINTERN VALUE
_wrap_new_ApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplVerID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplVerID";
  
  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 ;
  FIX::ApplVerID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplVerID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplVerID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplVerID(FIX::ApplVerID *arg1) {
    delete arg1;
}

swig_class cHandlInst;

SWIGINTERN VALUE
_wrap_new_HandlInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HandlInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HandlInst";
  
  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 ;
  FIX::HandlInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HandlInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::HandlInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HandlInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HandlInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HandlInst(FIX::HandlInst *arg1) {
    delete arg1;
}

swig_class cListUpdateAction;

SWIGINTERN VALUE
_wrap_new_ListUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListUpdateAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListUpdateAction";
  
  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 ;
  FIX::ListUpdateAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListUpdateAction";
  
  if ((argc < 1) || (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), "in method '" "FIX::ListUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListUpdateAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListUpdateAction(FIX::ListUpdateAction *arg1) {
    delete arg1;
}

swig_class cNestedInstrAttribValue;

SWIGINTERN VALUE
_wrap_new_NestedInstrAttribValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NestedInstrAttribValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribValue";
  
  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 ;
  FIX::NestedInstrAttribValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NestedInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NestedInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NestedInstrAttribValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedInstrAttribValue(FIX::NestedInstrAttribValue *arg1) {
    delete arg1;
}

swig_class cTradingSessionSubID;

SWIGINTERN VALUE
_wrap_new_TradingSessionSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradingSessionSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionSubID";
  
  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 ;
  FIX::TradingSessionSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradingSessionSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingSessionSubID(FIX::TradingSessionSubID *arg1) {
    delete arg1;
}

swig_class cRFQReqID;

SWIGINTERN VALUE
_wrap_new_RFQReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RFQReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RFQReqID";
  
  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 ;
  FIX::RFQReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RFQReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RFQReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RFQReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RFQReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RFQReqID(FIX::RFQReqID *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityExchange;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskSecurityExchange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::RelationshipRiskSecurityExchange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskSecurityExchange";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::RelationshipRiskSecurityExchange *)new FIX::RelationshipRiskSecurityExchange((FIX::EXCHANGE const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityExchange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityExchange__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_RelationshipRiskSecurityExchange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityExchange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityExchange(FIX::RelationshipRiskSecurityExchange *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSymbolSfx;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSymbolSfx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbolSfx";
  
  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 ;
  FIX::UnderlyingLegSymbolSfx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbolSfx";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSymbolSfx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSymbolSfx(FIX::UnderlyingLegSymbolSfx *arg1) {
    delete arg1;
}

swig_class cLiquidityNumSecurities;

SWIGINTERN VALUE
_wrap_new_LiquidityNumSecurities__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LiquidityNumSecurities *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityNumSecurities";
  
  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 ;
  FIX::LiquidityNumSecurities *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityNumSecurities";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LiquidityNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LiquidityNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LiquidityNumSecurities'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityNumSecurities(FIX::LiquidityNumSecurities *arg1) {
    delete arg1;
}

swig_class cNoMsgTypes;

SWIGINTERN VALUE
_wrap_new_NoMsgTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMsgTypes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMsgTypes";
  
  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 ;
  FIX::NoMsgTypes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMsgTypes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMsgTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMsgTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMsgTypes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMsgTypes(FIX::NoMsgTypes *arg1) {
    delete arg1;
}

swig_class cTradSesStartTime;

SWIGINTERN VALUE
_wrap_new_TradSesStartTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesStartTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  
  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 ;
  FIX::TradSesStartTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  
  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), "in method '" "FIX::TradSesStartTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TradSesStartTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TradSesStartTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesStartTime";
  
  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), "in method '" "FIX::TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TradSesStartTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesStartTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesStartTime(FIX::TradSesStartTime *arg1) {
    delete arg1;
}

swig_class cMDEntryType;

SWIGINTERN VALUE
_wrap_new_MDEntryType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryType";
  
  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 ;
  FIX::MDEntryType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryType";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDEntryType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryType(FIX::MDEntryType *arg1) {
    delete arg1;
}

swig_class cAgreementCurrency;

SWIGINTERN VALUE
_wrap_new_AgreementCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AgreementCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementCurrency";
  
  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 ;
  FIX::AgreementCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::AgreementCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AgreementCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AgreementCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementCurrency(FIX::AgreementCurrency *arg1) {
    delete arg1;
}

swig_class cPegMoveType;

SWIGINTERN VALUE
_wrap_new_PegMoveType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegMoveType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegMoveType";
  
  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 ;
  FIX::PegMoveType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegMoveType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegMoveType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegMoveType(FIX::PegMoveType *arg1) {
    delete arg1;
}

swig_class cAsgnReqID;

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


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

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


SWIGINTERN VALUE _wrap_new_AsgnReqID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_AsgnReqID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AsgnReqID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AsgnReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AsgnReqID(FIX::AsgnReqID *arg1) {
    delete arg1;
}

swig_class cPegDifference;

SWIGINTERN VALUE
_wrap_new_PegDifference__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegDifference *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegDifference";
  
  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 ;
  FIX::PegDifference *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegDifference";
  
  if ((argc < 1) || (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), "in method '" "FIX::PegDifference" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegDifference" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegDifference'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegDifference(FIX::PegDifference *arg1) {
    delete arg1;
}

swig_class cSpread;

SWIGINTERN VALUE
_wrap_new_Spread__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Spread *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Spread";
  
  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 ;
  FIX::Spread *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Spread";
  
  if ((argc < 1) || (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), "in method '" "FIX::Spread" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Spread" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Spread'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Spread(FIX::Spread *arg1) {
    delete arg1;
}

swig_class cEncodedAllocTextLen;

SWIGINTERN VALUE
_wrap_new_EncodedAllocTextLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedAllocTextLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocTextLen";
  
  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 ;
  FIX::EncodedAllocTextLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedAllocTextLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedAllocTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedAllocTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedAllocTextLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedAllocTextLen(FIX::EncodedAllocTextLen *arg1) {
    delete arg1;
}

swig_class cOutsideIndexPct;

SWIGINTERN VALUE
_wrap_new_OutsideIndexPct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OutsideIndexPct *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OutsideIndexPct";
  
  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 ;
  FIX::OutsideIndexPct *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OutsideIndexPct";
  
  if ((argc < 1) || (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), "in method '" "FIX::OutsideIndexPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OutsideIndexPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OutsideIndexPct'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OutsideIndexPct(FIX::OutsideIndexPct *arg1) {
    delete arg1;
}

swig_class cDerivFlexProductEligibilityIndicator;

SWIGINTERN VALUE
_wrap_new_DerivFlexProductEligibilityIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivFlexProductEligibilityIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivFlexProductEligibilityIndicator";
  
  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 ;
  FIX::DerivFlexProductEligibilityIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivFlexProductEligibilityIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivFlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivFlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivFlexProductEligibilityIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivFlexProductEligibilityIndicator(FIX::DerivFlexProductEligibilityIndicator *arg1) {
    delete arg1;
}

swig_class cAvgPxIndicator;

SWIGINTERN VALUE
_wrap_new_AvgPxIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AvgPxIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPxIndicator";
  
  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 ;
  FIX::AvgPxIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPxIndicator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AvgPxIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AvgPxIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AvgPxIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPxIndicator(FIX::AvgPxIndicator *arg1) {
    delete arg1;
}

swig_class cNoIOIQualifiers;

SWIGINTERN VALUE
_wrap_new_NoIOIQualifiers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoIOIQualifiers *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoIOIQualifiers";
  
  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 ;
  FIX::NoIOIQualifiers *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoIOIQualifiers";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoIOIQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoIOIQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoIOIQualifiers'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoIOIQualifiers(FIX::NoIOIQualifiers *arg1) {
    delete arg1;
}

swig_class cCancellationRights;

SWIGINTERN VALUE
_wrap_new_CancellationRights__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CancellationRights *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CancellationRights";
  
  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 ;
  FIX::CancellationRights *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CancellationRights";
  
  if ((argc < 1) || (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), "in method '" "FIX::CancellationRights" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CancellationRights" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CancellationRights'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CancellationRights(FIX::CancellationRights *arg1) {
    delete arg1;
}

swig_class cListSeqNo;

SWIGINTERN VALUE
_wrap_new_ListSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListSeqNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListSeqNo";
  
  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 ;
  FIX::ListSeqNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListSeqNo";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListSeqNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListSeqNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListSeqNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListSeqNo(FIX::ListSeqNo *arg1) {
    delete arg1;
}

swig_class cCardIssNum;

SWIGINTERN VALUE
_wrap_new_CardIssNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CardIssNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardIssNum";
  
  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 ;
  FIX::CardIssNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardIssNum";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CardIssNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CardIssNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CardIssNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CardIssNum(FIX::CardIssNum *arg1) {
    delete arg1;
}

swig_class cRiskCFICode;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskCFICode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskCFICode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskCFICode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskCFICode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskCFICode(FIX::RiskCFICode *arg1) {
    delete arg1;
}

swig_class cEncodedMktSegmDesc;

SWIGINTERN VALUE
_wrap_new_EncodedMktSegmDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedMktSegmDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDesc";
  
  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 ;
  FIX::EncodedMktSegmDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedMktSegmDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedMktSegmDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedMktSegmDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedMktSegmDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedMktSegmDesc(FIX::EncodedMktSegmDesc *arg1) {
    delete arg1;
}

swig_class cDerivativeEventType;

SWIGINTERN VALUE
_wrap_new_DerivativeEventType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEventType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventType";
  
  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 ;
  FIX::DerivativeEventType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEventType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventType(FIX::DerivativeEventType *arg1) {
    delete arg1;
}

swig_class cDerivativeMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeMaturityMonthYear *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityMonthYear";
  
  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 ;
  FIX::DerivativeMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMaturityMonthYear(FIX::DerivativeMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cSideTradeReportID;

SWIGINTERN VALUE
_wrap_new_SideTradeReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideTradeReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTradeReportID";
  
  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 ;
  FIX::SideTradeReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTradeReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideTradeReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTradeReportID(FIX::SideTradeReportID *arg1) {
    delete arg1;
}

swig_class cNoQuoteSets;

SWIGINTERN VALUE
_wrap_new_NoQuoteSets__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoQuoteSets *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteSets";
  
  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 ;
  FIX::NoQuoteSets *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteSets";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoQuoteSets" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoQuoteSets" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoQuoteSets'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoQuoteSets(FIX::NoQuoteSets *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityDesc;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityDesc(FIX::RelationshipRiskSecurityDesc *arg1) {
    delete arg1;
}

swig_class cNested4PartySubIDType;

SWIGINTERN VALUE
_wrap_new_Nested4PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested4PartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubIDType";
  
  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 ;
  FIX::Nested4PartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested4PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested4PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested4PartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartySubIDType(FIX::Nested4PartySubIDType *arg1) {
    delete arg1;
}

swig_class cFillPx;

SWIGINTERN VALUE
_wrap_new_FillPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FillPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillPx";
  
  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 ;
  FIX::FillPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::FillPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FillPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FillPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FillPx(FIX::FillPx *arg1) {
    delete arg1;
}

swig_class cStrikeExerciseStyle;

SWIGINTERN VALUE
_wrap_new_StrikeExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikeExerciseStyle *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeExerciseStyle";
  
  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 ;
  FIX::StrikeExerciseStyle *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeExerciseStyle";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StrikeExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikeExerciseStyle'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeExerciseStyle(FIX::StrikeExerciseStyle *arg1) {
    delete arg1;
}

swig_class cDeskID;

SWIGINTERN VALUE
_wrap_new_DeskID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeskID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskID";
  
  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 ;
  FIX::DeskID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeskID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeskID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeskID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskID(FIX::DeskID *arg1) {
    delete arg1;
}

swig_class cCrossPercent;

SWIGINTERN VALUE
_wrap_new_CrossPercent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CrossPercent *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossPercent";
  
  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 ;
  FIX::CrossPercent *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossPercent";
  
  if ((argc < 1) || (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), "in method '" "FIX::CrossPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CrossPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CrossPercent'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossPercent(FIX::CrossPercent *arg1) {
    delete arg1;
}

swig_class cMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityMonthYear *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYear";
  
  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 ;
  FIX::MaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYear(FIX::MaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cComplexEventPrice;

SWIGINTERN VALUE
_wrap_new_ComplexEventPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPrice";
  
  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 ;
  FIX::ComplexEventPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::ComplexEventPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPrice(FIX::ComplexEventPrice *arg1) {
    delete arg1;
}

swig_class cNoNewsRefIDs;

SWIGINTERN VALUE
_wrap_new_NoNewsRefIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNewsRefIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNewsRefIDs";
  
  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 ;
  FIX::NoNewsRefIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNewsRefIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNewsRefIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNewsRefIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNewsRefIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNewsRefIDs(FIX::NoNewsRefIDs *arg1) {
    delete arg1;
}

swig_class cUnderlyingCapValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingCapValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCapValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCapValue";
  
  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 ;
  FIX::UnderlyingCapValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCapValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCapValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCapValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCapValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCapValue(FIX::UnderlyingCapValue *arg1) {
    delete arg1;
}

swig_class cCPRegType;

SWIGINTERN VALUE
_wrap_new_CPRegType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CPRegType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CPRegType";
  
  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 ;
  FIX::CPRegType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CPRegType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CPRegType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CPRegType(FIX::CPRegType *arg1) {
    delete arg1;
}

swig_class cCashDistribAgentCode;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashDistribAgentCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentCode";
  
  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 ;
  FIX::CashDistribAgentCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashDistribAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashDistribAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashDistribAgentCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentCode(FIX::CashDistribAgentCode *arg1) {
    delete arg1;
}

swig_class cExecPriceType;

SWIGINTERN VALUE
_wrap_new_ExecPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceType";
  
  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 ;
  FIX::ExecPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceType";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecPriceType(FIX::ExecPriceType *arg1) {
    delete arg1;
}

swig_class cLegAllocID;

SWIGINTERN VALUE
_wrap_new_LegAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegAllocID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocID";
  
  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 ;
  FIX::LegAllocID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegAllocID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocID(FIX::LegAllocID *arg1) {
    delete arg1;
}

swig_class cMDEntryTime;

SWIGINTERN VALUE
_wrap_new_MDEntryTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryTime";
  
  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 ;
  FIX::MDEntryTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDEntryTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryTime(FIX::MDEntryTime *arg1) {
    delete arg1;
}

swig_class cTotalNumSecurities;

SWIGINTERN VALUE
_wrap_new_TotalNumSecurities__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalNumSecurities *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurities";
  
  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 ;
  FIX::TotalNumSecurities *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurities";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotalNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalNumSecurities'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNumSecurities(FIX::TotalNumSecurities *arg1) {
    delete arg1;
}

swig_class cAllocSettlInstType;

SWIGINTERN VALUE
_wrap_new_AllocSettlInstType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocSettlInstType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlInstType";
  
  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 ;
  FIX::AllocSettlInstType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlInstType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocSettlInstType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocSettlInstType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocSettlInstType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocSettlInstType(FIX::AllocSettlInstType *arg1) {
    delete arg1;
}

swig_class cTargetPartyID;

SWIGINTERN VALUE
_wrap_new_TargetPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyID";
  
  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 ;
  FIX::TargetPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TargetPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetPartyID(FIX::TargetPartyID *arg1) {
    delete arg1;
}

swig_class cDerivativeStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeStrikeCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeCurrency";
  
  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 ;
  FIX::DerivativeStrikeCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeStrikeCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikeCurrency(FIX::DerivativeStrikeCurrency *arg1) {
    delete arg1;
}

swig_class cStatsType;

SWIGINTERN VALUE
_wrap_new_StatsType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StatsType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatsType";
  
  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 ;
  FIX::StatsType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatsType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StatsType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StatsType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StatsType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StatsType(FIX::StatsType *arg1) {
    delete arg1;
}

swig_class cApplExtID;

SWIGINTERN VALUE
_wrap_new_ApplExtID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplExtID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplExtID";
  
  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 ;
  FIX::ApplExtID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplExtID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplExtID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplExtID(FIX::ApplExtID *arg1) {
    delete arg1;
}

swig_class cSettlementCycleNo;

SWIGINTERN VALUE
_wrap_new_SettlementCycleNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlementCycleNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlementCycleNo";
  
  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 ;
  FIX::SettlementCycleNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlementCycleNo";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlementCycleNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlementCycleNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlementCycleNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlementCycleNo(FIX::SettlementCycleNo *arg1) {
    delete arg1;
}

swig_class cUnderlyingStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_UnderlyingStrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingStrikeCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikeCurrency";
  
  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 ;
  FIX::UnderlyingStrikeCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStrikeCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingStrikeCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStrikeCurrency(FIX::UnderlyingStrikeCurrency *arg1) {
    delete arg1;
}

swig_class cTradSesMode;

SWIGINTERN VALUE
_wrap_new_TradSesMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesMode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesMode";
  
  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 ;
  FIX::TradSesMode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesMode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradSesMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesMode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesMode(FIX::TradSesMode *arg1) {
    delete arg1;
}

swig_class cSettlInstSource;

SWIGINTERN VALUE
_wrap_new_SettlInstSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstSource";
  
  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 ;
  FIX::SettlInstSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlInstSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstSource(FIX::SettlInstSource *arg1) {
    delete arg1;
}

swig_class cPartyAltSubIDType;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyAltSubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyAltSubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyAltSubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyAltSubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyAltSubIDType(FIX::PartyAltSubIDType *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityDesc";
  
  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 ;
  FIX::UnderlyingLegSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityDesc(FIX::UnderlyingLegSecurityDesc *arg1) {
    delete arg1;
}

swig_class cNoDerivativeInstrumentParties;

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrumentParties__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDerivativeInstrumentParties *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentParties";
  
  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 ;
  FIX::NoDerivativeInstrumentParties *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrumentParties";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoDerivativeInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDerivativeInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDerivativeInstrumentParties'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeInstrumentParties(FIX::NoDerivativeInstrumentParties *arg1) {
    delete arg1;
}

swig_class cDerivativeEventTime;

SWIGINTERN VALUE
_wrap_new_DerivativeEventTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEventTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  
  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 ;
  FIX::DerivativeEventTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  
  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), "in method '" "FIX::DerivativeEventTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::DerivativeEventTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::DerivativeEventTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventTime";
  
  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), "in method '" "FIX::DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::DerivativeEventTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEventTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventTime(FIX::DerivativeEventTime *arg1) {
    delete arg1;
}

swig_class cTickIncrement;

SWIGINTERN VALUE
_wrap_new_TickIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TickIncrement *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickIncrement";
  
  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 ;
  FIX::TickIncrement *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickIncrement";
  
  if ((argc < 1) || (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), "in method '" "FIX::TickIncrement" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TickIncrement" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TickIncrement'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TickIncrement(FIX::TickIncrement *arg1) {
    delete arg1;
}

swig_class cUndlyInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UndlyInstrumentPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyID";
  
  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 ;
  FIX::UndlyInstrumentPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UndlyInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UndlyInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UndlyInstrumentPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartyID(FIX::UndlyInstrumentPartyID *arg1) {
    delete arg1;
}

swig_class cNoUndlyInstrumentParties;

SWIGINTERN VALUE
_wrap_new_NoUndlyInstrumentParties__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoUndlyInstrumentParties *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentParties";
  
  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 ;
  FIX::NoUndlyInstrumentParties *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentParties";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoUndlyInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoUndlyInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoUndlyInstrumentParties'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUndlyInstrumentParties(FIX::NoUndlyInstrumentParties *arg1) {
    delete arg1;
}

swig_class cExpType;

SWIGINTERN VALUE
_wrap_new_ExpType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExpType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpType";
  
  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 ;
  FIX::ExpType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExpType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExpType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExpType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpType(FIX::ExpType *arg1) {
    delete arg1;
}

swig_class cSecondaryClOrdID;

SWIGINTERN VALUE
_wrap_new_SecondaryClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryClOrdID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryClOrdID";
  
  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 ;
  FIX::SecondaryClOrdID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryClOrdID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryClOrdID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryClOrdID(FIX::SecondaryClOrdID *arg1) {
    delete arg1;
}

swig_class cSettlInstTransType;

SWIGINTERN VALUE
_wrap_new_SettlInstTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstTransType";
  
  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 ;
  FIX::SettlInstTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstTransType";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlInstTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstTransType(FIX::SettlInstTransType *arg1) {
    delete arg1;
}

swig_class cSideComplianceID;

SWIGINTERN VALUE
_wrap_new_SideComplianceID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideComplianceID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideComplianceID";
  
  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 ;
  FIX::SideComplianceID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideComplianceID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideComplianceID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideComplianceID(FIX::SideComplianceID *arg1) {
    delete arg1;
}

swig_class cTradeRequestResult;

SWIGINTERN VALUE
_wrap_new_TradeRequestResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeRequestResult *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestResult";
  
  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 ;
  FIX::TradeRequestResult *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestResult";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeRequestResult'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestResult(FIX::TradeRequestResult *arg1) {
    delete arg1;
}

swig_class cOrigPosReqRefID;

SWIGINTERN VALUE
_wrap_new_OrigPosReqRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigPosReqRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigPosReqRefID";
  
  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 ;
  FIX::OrigPosReqRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigPosReqRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrigPosReqRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigPosReqRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigPosReqRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigPosReqRefID(FIX::OrigPosReqRefID *arg1) {
    delete arg1;
}

swig_class cOrigCrossID;

SWIGINTERN VALUE
_wrap_new_OrigCrossID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigCrossID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigCrossID";
  
  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 ;
  FIX::OrigCrossID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigCrossID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrigCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigCrossID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigCrossID(FIX::OrigCrossID *arg1) {
    delete arg1;
}

swig_class cTradeInputSource;

SWIGINTERN VALUE
_wrap_new_TradeInputSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeInputSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeInputSource";
  
  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 ;
  FIX::TradeInputSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeInputSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeInputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeInputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeInputSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeInputSource(FIX::TradeInputSource *arg1) {
    delete arg1;
}

swig_class cOrderQty2;

SWIGINTERN VALUE
_wrap_new_OrderQty2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderQty2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderQty2";
  
  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 ;
  FIX::OrderQty2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderQty2";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderQty2" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderQty2" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderQty2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderQty2(FIX::OrderQty2 *arg1) {
    delete arg1;
}

swig_class cTestMessageIndicator;

SWIGINTERN VALUE
_wrap_new_TestMessageIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TestMessageIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TestMessageIndicator";
  
  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 ;
  FIX::TestMessageIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TestMessageIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::TestMessageIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TestMessageIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TestMessageIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TestMessageIndicator(FIX::TestMessageIndicator *arg1) {
    delete arg1;
}

swig_class cContextPartySubID;

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


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

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


SWIGINTERN VALUE _wrap_new_ContextPartySubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContextPartySubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContextPartySubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContextPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContextPartySubID(FIX::ContextPartySubID *arg1) {
    delete arg1;
}

swig_class cDerivativeEventDate;

SWIGINTERN VALUE
_wrap_new_DerivativeEventDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEventDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventDate";
  
  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 ;
  FIX::DerivativeEventDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeEventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEventDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventDate(FIX::DerivativeEventDate *arg1) {
    delete arg1;
}

swig_class cSideGrossTradeAmt;

SWIGINTERN VALUE
_wrap_new_SideGrossTradeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideGrossTradeAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideGrossTradeAmt";
  
  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 ;
  FIX::SideGrossTradeAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideGrossTradeAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::SideGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideGrossTradeAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideGrossTradeAmt(FIX::SideGrossTradeAmt *arg1) {
    delete arg1;
}

swig_class cPeggedPrice;

SWIGINTERN VALUE
_wrap_new_PeggedPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PeggedPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PeggedPrice";
  
  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 ;
  FIX::PeggedPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PeggedPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::PeggedPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PeggedPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PeggedPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PeggedPrice(FIX::PeggedPrice *arg1) {
    delete arg1;
}

swig_class cExpirationCycle;

SWIGINTERN VALUE
_wrap_new_ExpirationCycle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExpirationCycle *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpirationCycle";
  
  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 ;
  FIX::ExpirationCycle *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpirationCycle";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExpirationCycle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExpirationCycle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExpirationCycle'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpirationCycle(FIX::ExpirationCycle *arg1) {
    delete arg1;
}

swig_class cAllocCancReplaceReason;

SWIGINTERN VALUE
_wrap_new_AllocCancReplaceReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocCancReplaceReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocCancReplaceReason";
  
  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 ;
  FIX::AllocCancReplaceReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocCancReplaceReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocCancReplaceReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocCancReplaceReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocCancReplaceReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocCancReplaceReason(FIX::AllocCancReplaceReason *arg1) {
    delete arg1;
}

swig_class cCxlRejReason;

SWIGINTERN VALUE
_wrap_new_CxlRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CxlRejReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlRejReason";
  
  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 ;
  FIX::CxlRejReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlRejReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CxlRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CxlRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CxlRejReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlRejReason(FIX::CxlRejReason *arg1) {
    delete arg1;
}

swig_class cBeginString;

SWIGINTERN VALUE
_wrap_new_BeginString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BeginString *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BeginString";
  
  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 ;
  FIX::BeginString *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BeginString";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BeginString" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BeginString" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BeginString'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BeginString(FIX::BeginString *arg1) {
    delete arg1;
}

swig_class cDeliverToSubID;

SWIGINTERN VALUE
_wrap_new_DeliverToSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeliverToSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToSubID";
  
  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 ;
  FIX::DeliverToSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeliverToSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeliverToSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeliverToSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliverToSubID(FIX::DeliverToSubID *arg1) {
    delete arg1;
}

swig_class cNoRelatedPartyAltIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelatedPartyAltIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartyAltIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedPartyAltIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelatedPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelatedPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelatedPartyAltIDs *)new FIX::NoRelatedPartyAltIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelatedPartyAltIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelatedPartyAltIDs__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_NoRelatedPartyAltIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelatedPartyAltIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedPartyAltIDs(FIX::NoRelatedPartyAltIDs *arg1) {
    delete arg1;
}

swig_class cRiskProductComplex;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskProductComplex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskProductComplex__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskProductComplex__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskProductComplex'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskProductComplex(FIX::RiskProductComplex *arg1) {
    delete arg1;
}

swig_class cLegPriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_LegPriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegPriceUnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasureQty";
  
  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 ;
  FIX::LegPriceUnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceUnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegPriceUnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPriceUnitOfMeasureQty(FIX::LegPriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cNoCollInquiryQualifier;

SWIGINTERN VALUE
_wrap_new_NoCollInquiryQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoCollInquiryQualifier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCollInquiryQualifier";
  
  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 ;
  FIX::NoCollInquiryQualifier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoCollInquiryQualifier";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoCollInquiryQualifier" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoCollInquiryQualifier" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoCollInquiryQualifier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoCollInquiryQualifier(FIX::NoCollInquiryQualifier *arg1) {
    delete arg1;
}

swig_class cOfferPx;

SWIGINTERN VALUE
_wrap_new_OfferPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OfferPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferPx";
  
  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 ;
  FIX::OfferPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::OfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OfferPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferPx(FIX::OfferPx *arg1) {
    delete arg1;
}

swig_class cTotalVolumeTradedDate;

SWIGINTERN VALUE
_wrap_new_TotalVolumeTradedDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalVolumeTradedDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedDate";
  
  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::UTCDATEONLY *arg1 = 0 ;
  FIX::TotalVolumeTradedDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalVolumeTradedDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::TotalVolumeTradedDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalVolumeTradedDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCDATEONLY * >(argp1);
  result = (FIX::TotalVolumeTradedDate *)new FIX::TotalVolumeTradedDate((FIX::UTCDATEONLY 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__UTCDATEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalVolumeTradedDate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalVolumeTradedDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalVolumeTradedDate(FIX::TotalVolumeTradedDate *arg1) {
    delete arg1;
}

swig_class cNoContAmts;

SWIGINTERN VALUE
_wrap_new_NoContAmts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoContAmts *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContAmts";
  
  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 ;
  FIX::NoContAmts *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContAmts";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoContAmts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoContAmts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoContAmts'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoContAmts(FIX::NoContAmts *arg1) {
    delete arg1;
}

swig_class cMinOfferSize;

SWIGINTERN VALUE
_wrap_new_MinOfferSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MinOfferSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinOfferSize";
  
  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 ;
  FIX::MinOfferSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinOfferSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::MinOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MinOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MinOfferSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MinOfferSize(FIX::MinOfferSize *arg1) {
    delete arg1;
}

swig_class cAvgParPx;

SWIGINTERN VALUE
_wrap_new_AvgParPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AvgParPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgParPx";
  
  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 ;
  FIX::AvgParPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgParPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::AvgParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AvgParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AvgParPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgParPx(FIX::AvgParPx *arg1) {
    delete arg1;
}

swig_class cLegFactor;

SWIGINTERN VALUE
_wrap_new_LegFactor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegFactor *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFactor";
  
  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 ;
  FIX::LegFactor *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegFactor";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegFactor'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegFactor(FIX::LegFactor *arg1) {
    delete arg1;
}

swig_class cRespondentType;

SWIGINTERN VALUE
_wrap_new_RespondentType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RespondentType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RespondentType";
  
  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 ;
  FIX::RespondentType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RespondentType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RespondentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RespondentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RespondentType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RespondentType(FIX::RespondentType *arg1) {
    delete arg1;
}

swig_class cDisplayLowQty;

SWIGINTERN VALUE
_wrap_new_DisplayLowQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DisplayLowQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayLowQty";
  
  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 ;
  FIX::DisplayLowQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayLowQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::DisplayLowQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DisplayLowQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DisplayLowQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayLowQty(FIX::DisplayLowQty *arg1) {
    delete arg1;
}

swig_class cDKReason;

SWIGINTERN VALUE
_wrap_new_DKReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DKReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DKReason";
  
  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 ;
  FIX::DKReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DKReason";
  
  if ((argc < 1) || (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), "in method '" "FIX::DKReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DKReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DKReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DKReason(FIX::DKReason *arg1) {
    delete arg1;
}

swig_class cBenchmarkPrice;

SWIGINTERN VALUE
_wrap_new_BenchmarkPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BenchmarkPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPrice";
  
  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 ;
  FIX::BenchmarkPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::BenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BenchmarkPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkPrice(FIX::BenchmarkPrice *arg1) {
    delete arg1;
}

swig_class cListID;

SWIGINTERN VALUE
_wrap_new_ListID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListID";
  
  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 ;
  FIX::ListID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListID(FIX::ListID *arg1) {
    delete arg1;
}

swig_class cLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_LegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltID";
  
  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 ;
  FIX::LegSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityAltID(FIX::LegSecurityAltID *arg1) {
    delete arg1;
}

swig_class cPositionEffect;

SWIGINTERN VALUE
_wrap_new_PositionEffect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PositionEffect *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionEffect";
  
  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 ;
  FIX::PositionEffect *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionEffect";
  
  if ((argc < 1) || (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), "in method '" "FIX::PositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PositionEffect'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PositionEffect(FIX::PositionEffect *arg1) {
    delete arg1;
}

swig_class cRelatedPartySubIDType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartySubIDType(FIX::RelatedPartySubIDType *arg1) {
    delete arg1;
}

swig_class cTriggerAction;

SWIGINTERN VALUE
_wrap_new_TriggerAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerAction";
  
  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 ;
  FIX::TriggerAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerAction";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerAction(FIX::TriggerAction *arg1) {
    delete arg1;
}

swig_class cRefOrderID;

SWIGINTERN VALUE
_wrap_new_RefOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefOrderID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrderID";
  
  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 ;
  FIX::RefOrderID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrderID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefOrderID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefOrderID(FIX::RefOrderID *arg1) {
    delete arg1;
}

swig_class cClearingInstruction;

SWIGINTERN VALUE
_wrap_new_ClearingInstruction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClearingInstruction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingInstruction";
  
  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 ;
  FIX::ClearingInstruction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingInstruction";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClearingInstruction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClearingInstruction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClearingInstruction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingInstruction(FIX::ClearingInstruction *arg1) {
    delete arg1;
}

swig_class cSettlInstCode;

SWIGINTERN VALUE
_wrap_new_SettlInstCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstCode";
  
  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 ;
  FIX::SettlInstCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlInstCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstCode(FIX::SettlInstCode *arg1) {
    delete arg1;
}

swig_class cNumDaysInterest;

SWIGINTERN VALUE
_wrap_new_NumDaysInterest__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NumDaysInterest *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumDaysInterest";
  
  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 ;
  FIX::NumDaysInterest *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumDaysInterest";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NumDaysInterest" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NumDaysInterest" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NumDaysInterest'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NumDaysInterest(FIX::NumDaysInterest *arg1) {
    delete arg1;
}

swig_class cOpenCloseSettlFlag;

SWIGINTERN VALUE
_wrap_new_OpenCloseSettlFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OpenCloseSettlFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettlFlag";
  
  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 ;
  FIX::OpenCloseSettlFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettlFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::OpenCloseSettlFlag" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OpenCloseSettlFlag" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OpenCloseSettlFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenCloseSettlFlag(FIX::OpenCloseSettlFlag *arg1) {
    delete arg1;
}

swig_class cNoComplexEventDates;

SWIGINTERN VALUE
_wrap_new_NoComplexEventDates__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoComplexEventDates *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventDates";
  
  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 ;
  FIX::NoComplexEventDates *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEventDates";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoComplexEventDates" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoComplexEventDates" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoComplexEventDates'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoComplexEventDates(FIX::NoComplexEventDates *arg1) {
    delete arg1;
}

swig_class cDerivativeEncodedIssuerLen;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEncodedIssuerLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuerLen";
  
  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 ;
  FIX::DerivativeEncodedIssuerLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedIssuerLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeEncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEncodedIssuerLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEncodedIssuerLen(FIX::DerivativeEncodedIssuerLen *arg1) {
    delete arg1;
}

swig_class cStrikeMultiplier;

SWIGINTERN VALUE
_wrap_new_StrikeMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikeMultiplier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeMultiplier";
  
  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 ;
  FIX::StrikeMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::StrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikeMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeMultiplier(FIX::StrikeMultiplier *arg1) {
    delete arg1;
}

swig_class cDiscretionMoveType;

SWIGINTERN VALUE
_wrap_new_DiscretionMoveType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionMoveType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionMoveType";
  
  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 ;
  FIX::DiscretionMoveType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionMoveType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DiscretionMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionMoveType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionMoveType(FIX::DiscretionMoveType *arg1) {
    delete arg1;
}

swig_class cListNoOrds;

SWIGINTERN VALUE
_wrap_new_ListNoOrds__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListNoOrds *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListNoOrds";
  
  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 ;
  FIX::ListNoOrds *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListNoOrds";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListNoOrds" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListNoOrds" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListNoOrds'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListNoOrds(FIX::ListNoOrds *arg1) {
    delete arg1;
}

swig_class cRelatedPartyIDSource;

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


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

SWIGINTERN VALUE
_wrap_new_RelatedPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  FIX::RelatedPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelatedPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelatedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelatedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RelatedPartyIDSource *)new FIX::RelatedPartyIDSource((FIX::CHAR const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelatedPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartyIDSource__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_RelatedPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartyIDSource(FIX::RelatedPartyIDSource *arg1) {
    delete arg1;
}

swig_class cPegSymbol;

SWIGINTERN VALUE
_wrap_new_PegSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegSymbol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSymbol";
  
  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 ;
  FIX::PegSymbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSymbol";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSymbol(FIX::PegSymbol *arg1) {
    delete arg1;
}

swig_class cDayAvgPx;

SWIGINTERN VALUE
_wrap_new_DayAvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DayAvgPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayAvgPx";
  
  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 ;
  FIX::DayAvgPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayAvgPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::DayAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DayAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DayAvgPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DayAvgPx(FIX::DayAvgPx *arg1) {
    delete arg1;
}

swig_class cHeadline;

SWIGINTERN VALUE
_wrap_new_Headline__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Headline *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Headline";
  
  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 ;
  FIX::Headline *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Headline";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Headline" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Headline" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Headline'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Headline(FIX::Headline *arg1) {
    delete arg1;
}

swig_class cNestedPartySubID;

SWIGINTERN VALUE
_wrap_new_NestedPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NestedPartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubID";
  
  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 ;
  FIX::NestedPartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NestedPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NestedPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NestedPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartySubID(FIX::NestedPartySubID *arg1) {
    delete arg1;
}

swig_class cCardIssNo;

SWIGINTERN VALUE
_wrap_new_CardIssNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CardIssNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardIssNo";
  
  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 ;
  FIX::CardIssNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardIssNo";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CardIssNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CardIssNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CardIssNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CardIssNo(FIX::CardIssNo *arg1) {
    delete arg1;
}

swig_class cOptAttribute;

SWIGINTERN VALUE
_wrap_new_OptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OptAttribute *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptAttribute";
  
  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 ;
  FIX::OptAttribute *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptAttribute";
  
  if ((argc < 1) || (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), "in method '" "FIX::OptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OptAttribute'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OptAttribute(FIX::OptAttribute *arg1) {
    delete arg1;
}

swig_class cLastForwardPoints2;

SWIGINTERN VALUE
_wrap_new_LastForwardPoints2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastForwardPoints2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints2";
  
  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 ;
  FIX::LastForwardPoints2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints2";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastForwardPoints2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastForwardPoints2(FIX::LastForwardPoints2 *arg1) {
    delete arg1;
}

swig_class cMDUpdateType;

SWIGINTERN VALUE
_wrap_new_MDUpdateType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDUpdateType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateType";
  
  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 ;
  FIX::MDUpdateType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDUpdateType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDUpdateType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDUpdateType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDUpdateType(FIX::MDUpdateType *arg1) {
    delete arg1;
}

swig_class cTickDirection;

SWIGINTERN VALUE
_wrap_new_TickDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TickDirection *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickDirection";
  
  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 ;
  FIX::TickDirection *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickDirection";
  
  if ((argc < 1) || (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), "in method '" "FIX::TickDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TickDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TickDirection'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TickDirection(FIX::TickDirection *arg1) {
    delete arg1;
}

swig_class cLegRedemptionDate;

SWIGINTERN VALUE
_wrap_new_LegRedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegRedemptionDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRedemptionDate";
  
  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 ;
  FIX::LegRedemptionDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRedemptionDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegRedemptionDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRedemptionDate(FIX::LegRedemptionDate *arg1) {
    delete arg1;
}

swig_class cStrikePrice;

SWIGINTERN VALUE
_wrap_new_StrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePrice";
  
  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 ;
  FIX::StrikePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::StrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePrice(FIX::StrikePrice *arg1) {
    delete arg1;
}

swig_class cEncodedIssuer;

SWIGINTERN VALUE
_wrap_new_EncodedIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedIssuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuer";
  
  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 ;
  FIX::EncodedIssuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuer";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedIssuer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedIssuer(FIX::EncodedIssuer *arg1) {
    delete arg1;
}

swig_class cYieldType;

SWIGINTERN VALUE
_wrap_new_YieldType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::YieldType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldType";
  
  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 ;
  FIX::YieldType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::YieldType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::YieldType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_YieldType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldType(FIX::YieldType *arg1) {
    delete arg1;
}

swig_class cTradingReferencePrice;

SWIGINTERN VALUE
_wrap_new_TradingReferencePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradingReferencePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingReferencePrice";
  
  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 ;
  FIX::TradingReferencePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingReferencePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradingReferencePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingReferencePrice(FIX::TradingReferencePrice *arg1) {
    delete arg1;
}

swig_class cMDEntrySpotRate;

SWIGINTERN VALUE
_wrap_new_MDEntrySpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntrySpotRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySpotRate";
  
  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 ;
  FIX::MDEntrySpotRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySpotRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDEntrySpotRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntrySpotRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntrySpotRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntrySpotRate(FIX::MDEntrySpotRate *arg1) {
    delete arg1;
}

swig_class cParticipationRate;

SWIGINTERN VALUE
_wrap_new_ParticipationRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ParticipationRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ParticipationRate";
  
  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 ;
  FIX::ParticipationRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ParticipationRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::ParticipationRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ParticipationRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ParticipationRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ParticipationRate(FIX::ParticipationRate *arg1) {
    delete arg1;
}

swig_class cPegScope;

SWIGINTERN VALUE
_wrap_new_PegScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegScope *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegScope";
  
  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 ;
  FIX::PegScope *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegScope";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegScope'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegScope(FIX::PegScope *arg1) {
    delete arg1;
}

swig_class cInterestAtMaturity;

SWIGINTERN VALUE
_wrap_new_InterestAtMaturity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InterestAtMaturity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InterestAtMaturity";
  
  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 ;
  FIX::InterestAtMaturity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InterestAtMaturity";
  
  if ((argc < 1) || (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), "in method '" "FIX::InterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InterestAtMaturity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InterestAtMaturity(FIX::InterestAtMaturity *arg1) {
    delete arg1;
}

swig_class cLegIndividualAllocID;

SWIGINTERN VALUE
_wrap_new_LegIndividualAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegIndividualAllocID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIndividualAllocID";
  
  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 ;
  FIX::LegIndividualAllocID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIndividualAllocID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegIndividualAllocID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIndividualAllocID(FIX::LegIndividualAllocID *arg1) {
    delete arg1;
}

swig_class cAllowableOneSidednessValue;

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllowableOneSidednessValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessValue";
  
  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 ;
  FIX::AllowableOneSidednessValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllowableOneSidednessValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllowableOneSidednessValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllowableOneSidednessValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllowableOneSidednessValue(FIX::AllowableOneSidednessValue *arg1) {
    delete arg1;
}

swig_class cCashSettlAgentName;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashSettlAgentName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentName";
  
  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 ;
  FIX::CashSettlAgentName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashSettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashSettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashSettlAgentName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentName(FIX::CashSettlAgentName *arg1) {
    delete arg1;
}

swig_class cContraTradeQty;

SWIGINTERN VALUE
_wrap_new_ContraTradeQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContraTradeQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeQty";
  
  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 ;
  FIX::ContraTradeQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTradeQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContraTradeQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContraTradeQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContraTradeQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraTradeQty(FIX::ContraTradeQty *arg1) {
    delete arg1;
}

swig_class cLegMaturityTime;

SWIGINTERN VALUE
_wrap_new_LegMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegMaturityTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityTime";
  
  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 ;
  FIX::LegMaturityTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegMaturityTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegMaturityTime(FIX::LegMaturityTime *arg1) {
    delete arg1;
}

swig_class cSettlDeliveryType;

SWIGINTERN VALUE
_wrap_new_SettlDeliveryType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlDeliveryType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDeliveryType";
  
  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 ;
  FIX::SettlDeliveryType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDeliveryType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlDeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlDeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlDeliveryType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDeliveryType(FIX::SettlDeliveryType *arg1) {
    delete arg1;
}

swig_class cSecondaryPriceLimitType;

SWIGINTERN VALUE
_wrap_new_SecondaryPriceLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryPriceLimitType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryPriceLimitType";
  
  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 ;
  FIX::SecondaryPriceLimitType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryPriceLimitType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryPriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryPriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryPriceLimitType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryPriceLimitType(FIX::SecondaryPriceLimitType *arg1) {
    delete arg1;
}

swig_class cMidPx;

SWIGINTERN VALUE
_wrap_new_MidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MidPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MidPx";
  
  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 ;
  FIX::MidPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MidPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::MidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MidPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MidPx(FIX::MidPx *arg1) {
    delete arg1;
}

swig_class cAvgPx;

SWIGINTERN VALUE
_wrap_new_AvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AvgPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPx";
  
  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 ;
  FIX::AvgPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::AvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AvgPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPx(FIX::AvgPx *arg1) {
    delete arg1;
}

swig_class cDiscretionLimitType;

SWIGINTERN VALUE
_wrap_new_DiscretionLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionLimitType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionLimitType";
  
  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 ;
  FIX::DiscretionLimitType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionLimitType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DiscretionLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionLimitType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionLimitType(FIX::DiscretionLimitType *arg1) {
    delete arg1;
}

swig_class cStrikeTime;

SWIGINTERN VALUE
_wrap_new_StrikeTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikeTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  
  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 ;
  FIX::StrikeTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  
  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), "in method '" "FIX::StrikeTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::StrikeTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::StrikeTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeTime";
  
  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), "in method '" "FIX::StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::StrikeTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikeTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeTime(FIX::StrikeTime *arg1) {
    delete arg1;
}

swig_class cSettlSessSubID;

SWIGINTERN VALUE
_wrap_new_SettlSessSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlSessSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlSessSubID";
  
  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 ;
  FIX::SettlSessSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlSessSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlSessSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlSessSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlSessSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlSessSubID(FIX::SettlSessSubID *arg1) {
    delete arg1;
}

swig_class cMailingDtls;

SWIGINTERN VALUE
_wrap_new_MailingDtls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MailingDtls *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MailingDtls";
  
  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 ;
  FIX::MailingDtls *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MailingDtls";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MailingDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MailingDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MailingDtls'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MailingDtls(FIX::MailingDtls *arg1) {
    delete arg1;
}

swig_class cBidID;

SWIGINTERN VALUE
_wrap_new_BidID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidID";
  
  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 ;
  FIX::BidID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidID(FIX::BidID *arg1) {
    delete arg1;
}

swig_class cPartyDetailsRequestResult;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyDetailsRequestResult(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyDetailsRequestResult__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyDetailsRequestResult__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyDetailsRequestResult'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyDetailsRequestResult(FIX::PartyDetailsRequestResult *arg1) {
    delete arg1;
}

swig_class cExerciseMethod;

SWIGINTERN VALUE
_wrap_new_ExerciseMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExerciseMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExerciseMethod";
  
  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 ;
  FIX::ExerciseMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExerciseMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExerciseMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExerciseMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExerciseMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExerciseMethod(FIX::ExerciseMethod *arg1) {
    delete arg1;
}

swig_class cCommCurrency;

SWIGINTERN VALUE
_wrap_new_CommCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CommCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CommCurrency";
  
  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 ;
  FIX::CommCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CommCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::CommCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CommCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CommCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CommCurrency(FIX::CommCurrency *arg1) {
    delete arg1;
}

swig_class cNoSettlOblig;

SWIGINTERN VALUE
_wrap_new_NoSettlOblig__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSettlOblig *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlOblig";
  
  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 ;
  FIX::NoSettlOblig *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlOblig";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSettlOblig" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSettlOblig" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSettlOblig'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlOblig(FIX::NoSettlOblig *arg1) {
    delete arg1;
}

swig_class cMaxPriceVariation;

SWIGINTERN VALUE
_wrap_new_MaxPriceVariation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaxPriceVariation *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceVariation";
  
  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 ;
  FIX::MaxPriceVariation *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxPriceVariation";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaxPriceVariation" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaxPriceVariation" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaxPriceVariation'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxPriceVariation(FIX::MaxPriceVariation *arg1) {
    delete arg1;
}

swig_class cWorkingIndicator;

SWIGINTERN VALUE
_wrap_new_WorkingIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::WorkingIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WorkingIndicator";
  
  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 ;
  FIX::WorkingIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WorkingIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::WorkingIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::WorkingIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_WorkingIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_WorkingIndicator(FIX::WorkingIndicator *arg1) {
    delete arg1;
}

swig_class cCashSettlAgentAcctName;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentAcctName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashSettlAgentAcctName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctName";
  
  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 ;
  FIX::CashSettlAgentAcctName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashSettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashSettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashSettlAgentAcctName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentAcctName(FIX::CashSettlAgentAcctName *arg1) {
    delete arg1;
}

swig_class cSellVolume;

SWIGINTERN VALUE
_wrap_new_SellVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SellVolume *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SellVolume";
  
  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 ;
  FIX::SellVolume *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SellVolume";
  
  if ((argc < 1) || (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), "in method '" "FIX::SellVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SellVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SellVolume'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SellVolume(FIX::SellVolume *arg1) {
    delete arg1;
}

swig_class cSideMultiLegReportingType;

SWIGINTERN VALUE
_wrap_new_SideMultiLegReportingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideMultiLegReportingType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideMultiLegReportingType";
  
  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 ;
  FIX::SideMultiLegReportingType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideMultiLegReportingType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideMultiLegReportingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideMultiLegReportingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideMultiLegReportingType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideMultiLegReportingType(FIX::SideMultiLegReportingType *arg1) {
    delete arg1;
}

swig_class cDerivativeEventText;

SWIGINTERN VALUE
_wrap_new_DerivativeEventText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEventText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventText";
  
  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 ;
  FIX::DerivativeEventText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeEventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEventText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventText(FIX::DerivativeEventText *arg1) {
    delete arg1;
}

swig_class cPegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_PegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityDesc";
  
  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 ;
  FIX::PegSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSecurityDesc(FIX::PegSecurityDesc *arg1) {
    delete arg1;
}

swig_class cAllocCustomerCapacity;

SWIGINTERN VALUE
_wrap_new_AllocCustomerCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocCustomerCapacity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocCustomerCapacity";
  
  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 ;
  FIX::AllocCustomerCapacity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocCustomerCapacity";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocCustomerCapacity" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocCustomerCapacity" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocCustomerCapacity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocCustomerCapacity(FIX::AllocCustomerCapacity *arg1) {
    delete arg1;
}

swig_class cConfirmRejReason;

SWIGINTERN VALUE
_wrap_new_ConfirmRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ConfirmRejReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRejReason";
  
  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 ;
  FIX::ConfirmRejReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRejReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ConfirmRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfirmRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfirmRejReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmRejReason(FIX::ConfirmRejReason *arg1) {
    delete arg1;
}

swig_class cBidRequestTransType;

SWIGINTERN VALUE
_wrap_new_BidRequestTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidRequestTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidRequestTransType";
  
  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 ;
  FIX::BidRequestTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidRequestTransType";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidRequestTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidRequestTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidRequestTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidRequestTransType(FIX::BidRequestTransType *arg1) {
    delete arg1;
}

swig_class cCashDistribAgentAcctNumber;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentAcctNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashDistribAgentAcctNumber *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctNumber";
  
  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 ;
  FIX::CashDistribAgentAcctNumber *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctNumber";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashDistribAgentAcctNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashDistribAgentAcctNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashDistribAgentAcctNumber'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentAcctNumber(FIX::CashDistribAgentAcctNumber *arg1) {
    delete arg1;
}

swig_class cLegExecInst;

SWIGINTERN VALUE
_wrap_new_LegExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegExecInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegExecInst";
  
  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 ;
  FIX::LegExecInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegExecInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegExecInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegExecInst(FIX::LegExecInst *arg1) {
    delete arg1;
}

swig_class cCapPrice;

SWIGINTERN VALUE
_wrap_new_CapPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CapPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CapPrice";
  
  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 ;
  FIX::CapPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CapPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::CapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CapPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CapPrice(FIX::CapPrice *arg1) {
    delete arg1;
}

swig_class cLegRepurchaseTerm;

SWIGINTERN VALUE
_wrap_new_LegRepurchaseTerm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegRepurchaseTerm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseTerm";
  
  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 ;
  FIX::LegRepurchaseTerm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseTerm";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegRepurchaseTerm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRepurchaseTerm(FIX::LegRepurchaseTerm *arg1) {
    delete arg1;
}

swig_class cRegistAcctType;

SWIGINTERN VALUE
_wrap_new_RegistAcctType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistAcctType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistAcctType";
  
  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 ;
  FIX::RegistAcctType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistAcctType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistAcctType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistAcctType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistAcctType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistAcctType(FIX::RegistAcctType *arg1) {
    delete arg1;
}

swig_class cMassActionRejectReason;

SWIGINTERN VALUE
_wrap_new_MassActionRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassActionRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionRejectReason";
  
  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 ;
  FIX::MassActionRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassActionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassActionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassActionRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionRejectReason(FIX::MassActionRejectReason *arg1) {
    delete arg1;
}

swig_class cDerivativePutOrCall;

SWIGINTERN VALUE
_wrap_new_DerivativePutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativePutOrCall *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePutOrCall";
  
  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 ;
  FIX::DerivativePutOrCall *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePutOrCall";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativePutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativePutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativePutOrCall'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePutOrCall(FIX::DerivativePutOrCall *arg1) {
    delete arg1;
}

swig_class cStartMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_StartMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StartMaturityMonthYear *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartMaturityMonthYear";
  
  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 ;
  FIX::StartMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::StartMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StartMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StartMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StartMaturityMonthYear(FIX::StartMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cCollApplType;

SWIGINTERN VALUE
_wrap_new_CollApplType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollApplType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollApplType";
  
  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 ;
  FIX::CollApplType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollApplType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollApplType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollApplType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollApplType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollApplType(FIX::CollApplType *arg1) {
    delete arg1;
}

swig_class cNoUnderlyingAmounts;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingAmounts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoUnderlyingAmounts *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingAmounts";
  
  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 ;
  FIX::NoUnderlyingAmounts *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingAmounts";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoUnderlyingAmounts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoUnderlyingAmounts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoUnderlyingAmounts'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingAmounts(FIX::NoUnderlyingAmounts *arg1) {
    delete arg1;
}

swig_class cConfirmType;

SWIGINTERN VALUE
_wrap_new_ConfirmType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ConfirmType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmType";
  
  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 ;
  FIX::ConfirmType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ConfirmType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfirmType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfirmType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmType(FIX::ConfirmType *arg1) {
    delete arg1;
}

swig_class cLegMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_LegMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegMaturityMonthYear *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityMonthYear";
  
  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 ;
  FIX::LegMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegMaturityMonthYear(FIX::LegMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cRelatdSym;

SWIGINTERN VALUE
_wrap_new_RelatdSym__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RelatdSym *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelatdSym";
  
  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 ;
  FIX::RelatdSym *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelatdSym";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RelatdSym" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelatdSym" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatdSym'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatdSym(FIX::RelatdSym *arg1) {
    delete arg1;
}

swig_class cRiskLimitAmount;

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


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

SWIGINTERN VALUE
_wrap_new_RiskLimitAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  FIX::RiskLimitAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskLimitAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::RiskLimitAmount *)new FIX::RiskLimitAmount((FIX::AMT const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskLimitAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskLimitAmount__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_RiskLimitAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskLimitAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskLimitAmount(FIX::RiskLimitAmount *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecuritySubType;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecuritySubType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecuritySubType";
  
  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 ;
  FIX::UnderlyingLegSecuritySubType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecuritySubType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecuritySubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecuritySubType(FIX::UnderlyingLegSecuritySubType *arg1) {
    delete arg1;
}

swig_class cNoUnderlyingSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoUnderlyingSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingSecurityAltID";
  
  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 ;
  FIX::NoUnderlyingSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingSecurityAltID";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoUnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoUnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoUnderlyingSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingSecurityAltID(FIX::NoUnderlyingSecurityAltID *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskCFICode;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskCFICode(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskCFICode__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskCFICode__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskCFICode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskCFICode(FIX::RelationshipRiskCFICode *arg1) {
    delete arg1;
}

swig_class cNoRelatedPartySubIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelatedPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelatedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelatedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelatedPartySubIDs *)new FIX::NoRelatedPartySubIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelatedPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelatedPartySubIDs__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_NoRelatedPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelatedPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedPartySubIDs(FIX::NoRelatedPartySubIDs *arg1) {
    delete arg1;
}

swig_class cRiskSymbolSfx;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSymbolSfx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSymbolSfx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSymbolSfx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSymbolSfx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSymbolSfx(FIX::RiskSymbolSfx *arg1) {
    delete arg1;
}

swig_class cMDQuoteType;

SWIGINTERN VALUE
_wrap_new_MDQuoteType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDQuoteType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDQuoteType";
  
  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 ;
  FIX::MDQuoteType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDQuoteType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDQuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDQuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDQuoteType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDQuoteType(FIX::MDQuoteType *arg1) {
    delete arg1;
}

swig_class cQtyType;

SWIGINTERN VALUE
_wrap_new_QtyType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QtyType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QtyType";
  
  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 ;
  FIX::QtyType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QtyType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QtyType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QtyType(FIX::QtyType *arg1) {
    delete arg1;
}

swig_class cQuoteRespType;

SWIGINTERN VALUE
_wrap_new_QuoteRespType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteRespType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespType";
  
  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 ;
  FIX::QuoteRespType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteRespType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRespType(FIX::QuoteRespType *arg1) {
    delete arg1;
}

swig_class cIOINaturalFlag;

SWIGINTERN VALUE
_wrap_new_IOINaturalFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOINaturalFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOINaturalFlag";
  
  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 ;
  FIX::IOINaturalFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOINaturalFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::IOINaturalFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOINaturalFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOINaturalFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOINaturalFlag(FIX::IOINaturalFlag *arg1) {
    delete arg1;
}

swig_class cBenchmarkCurvePoint;

SWIGINTERN VALUE
_wrap_new_BenchmarkCurvePoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BenchmarkCurvePoint *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurvePoint";
  
  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 ;
  FIX::BenchmarkCurvePoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurvePoint";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BenchmarkCurvePoint'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkCurvePoint(FIX::BenchmarkCurvePoint *arg1) {
    delete arg1;
}

swig_class cTradSesUpdateAction;

SWIGINTERN VALUE
_wrap_new_TradSesUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesUpdateAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesUpdateAction";
  
  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 ;
  FIX::TradSesUpdateAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesUpdateAction";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradSesUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesUpdateAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesUpdateAction(FIX::TradSesUpdateAction *arg1) {
    delete arg1;
}

swig_class cUnderlyingCashAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingCashAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCashAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashAmount";
  
  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 ;
  FIX::UnderlyingCashAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCashAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCashAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCashAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCashAmount(FIX::UnderlyingCashAmount *arg1) {
    delete arg1;
}

swig_class cCollAsgnID;

SWIGINTERN VALUE
_wrap_new_CollAsgnID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollAsgnID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnID";
  
  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 ;
  FIX::CollAsgnID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollAsgnID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollAsgnID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollAsgnID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnID(FIX::CollAsgnID *arg1) {
    delete arg1;
}

swig_class cExchangeRule;

SWIGINTERN VALUE
_wrap_new_ExchangeRule__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExchangeRule *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeRule";
  
  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 ;
  FIX::ExchangeRule *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeRule";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExchangeRule" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExchangeRule" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExchangeRule'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExchangeRule(FIX::ExchangeRule *arg1) {
    delete arg1;
}

swig_class cEncodedHeadline;

SWIGINTERN VALUE
_wrap_new_EncodedHeadline__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedHeadline *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadline";
  
  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 ;
  FIX::EncodedHeadline *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadline";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedHeadline" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedHeadline" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedHeadline'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedHeadline(FIX::EncodedHeadline *arg1) {
    delete arg1;
}

swig_class cRegistID;

SWIGINTERN VALUE
_wrap_new_RegistID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistID";
  
  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 ;
  FIX::RegistID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistID(FIX::RegistID *arg1) {
    delete arg1;
}

swig_class cCrossID;

SWIGINTERN VALUE
_wrap_new_CrossID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CrossID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossID";
  
  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 ;
  FIX::CrossID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CrossID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossID(FIX::CrossID *arg1) {
    delete arg1;
}

swig_class cNoExecs;

SWIGINTERN VALUE
_wrap_new_NoExecs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoExecs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExecs";
  
  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 ;
  FIX::NoExecs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoExecs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoExecs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoExecs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoExecs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoExecs(FIX::NoExecs *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityGroup;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityGroup *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityGroup";
  
  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 ;
  FIX::DerivativeSecurityGroup *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityGroup";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityGroup'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityGroup(FIX::DerivativeSecurityGroup *arg1) {
    delete arg1;
}

swig_class cSecondaryDisplayQty;

SWIGINTERN VALUE
_wrap_new_SecondaryDisplayQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryDisplayQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryDisplayQty";
  
  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 ;
  FIX::SecondaryDisplayQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryDisplayQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecondaryDisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryDisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryDisplayQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryDisplayQty(FIX::SecondaryDisplayQty *arg1) {
    delete arg1;
}

swig_class cRefMsgType;

SWIGINTERN VALUE
_wrap_new_RefMsgType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefMsgType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefMsgType";
  
  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 ;
  FIX::RefMsgType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefMsgType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefMsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefMsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefMsgType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefMsgType(FIX::RefMsgType *arg1) {
    delete arg1;
}

swig_class cStandInstDbID;

SWIGINTERN VALUE
_wrap_new_StandInstDbID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StandInstDbID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbID";
  
  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 ;
  FIX::StandInstDbID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StandInstDbID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StandInstDbID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StandInstDbID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StandInstDbID(FIX::StandInstDbID *arg1) {
    delete arg1;
}

swig_class cEncodedLegSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedLegSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedLegSecurityDescLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDescLen";
  
  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 ;
  FIX::EncodedLegSecurityDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegSecurityDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedLegSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedLegSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedLegSecurityDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegSecurityDescLen(FIX::EncodedLegSecurityDescLen *arg1) {
    delete arg1;
}

swig_class cDerivativeEventPx;

SWIGINTERN VALUE
_wrap_new_DerivativeEventPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEventPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventPx";
  
  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 ;
  FIX::DerivativeEventPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEventPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeEventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEventPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEventPx(FIX::DerivativeEventPx *arg1) {
    delete arg1;
}

swig_class cSettlObligSource;

SWIGINTERN VALUE
_wrap_new_SettlObligSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlObligSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligSource";
  
  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 ;
  FIX::SettlObligSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlObligSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlObligSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlObligSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligSource(FIX::SettlObligSource *arg1) {
    delete arg1;
}

swig_class cTrdSubType;

SWIGINTERN VALUE
_wrap_new_TrdSubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdSubType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdSubType";
  
  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 ;
  FIX::TrdSubType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdSubType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TrdSubType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdSubType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdSubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdSubType(FIX::TrdSubType *arg1) {
    delete arg1;
}

swig_class cEncodedUnderlyingIssuerLen;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedUnderlyingIssuerLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuerLen";
  
  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 ;
  FIX::EncodedUnderlyingIssuerLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuerLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedUnderlyingIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedUnderlyingIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedUnderlyingIssuerLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingIssuerLen(FIX::EncodedUnderlyingIssuerLen *arg1) {
    delete arg1;
}

swig_class cExecTransType;

SWIGINTERN VALUE
_wrap_new_ExecTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecTransType";
  
  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 ;
  FIX::ExecTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecTransType";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecTransType(FIX::ExecTransType *arg1) {
    delete arg1;
}

swig_class cBeginSeqNo;

SWIGINTERN VALUE
_wrap_new_BeginSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BeginSeqNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BeginSeqNo";
  
  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 ;
  FIX::BeginSeqNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BeginSeqNo";
  
  if ((argc < 1) || (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), "in method '" "FIX::BeginSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BeginSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BeginSeqNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BeginSeqNo(FIX::BeginSeqNo *arg1) {
    delete arg1;
}

swig_class cDayBookingInst;

SWIGINTERN VALUE
_wrap_new_DayBookingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DayBookingInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayBookingInst";
  
  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 ;
  FIX::DayBookingInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DayBookingInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::DayBookingInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DayBookingInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DayBookingInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DayBookingInst(FIX::DayBookingInst *arg1) {
    delete arg1;
}

swig_class cFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_FlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FlowScheduleType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlowScheduleType";
  
  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 ;
  FIX::FlowScheduleType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlowScheduleType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::FlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FlowScheduleType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FlowScheduleType(FIX::FlowScheduleType *arg1) {
    delete arg1;
}

swig_class cMDOriginType;

SWIGINTERN VALUE
_wrap_new_MDOriginType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDOriginType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDOriginType";
  
  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 ;
  FIX::MDOriginType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDOriginType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDOriginType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDOriginType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDOriginType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDOriginType(FIX::MDOriginType *arg1) {
    delete arg1;
}

swig_class cCollInquiryStatus;

SWIGINTERN VALUE
_wrap_new_CollInquiryStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollInquiryStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryStatus";
  
  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 ;
  FIX::CollInquiryStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollInquiryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollInquiryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollInquiryStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryStatus(FIX::CollInquiryStatus *arg1) {
    delete arg1;
}

swig_class cNoInstrAttrib;

SWIGINTERN VALUE
_wrap_new_NoInstrAttrib__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoInstrAttrib *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrAttrib";
  
  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 ;
  FIX::NoInstrAttrib *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrAttrib";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoInstrAttrib'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoInstrAttrib(FIX::NoInstrAttrib *arg1) {
    delete arg1;
}

swig_class cRegistEmail;

SWIGINTERN VALUE
_wrap_new_RegistEmail__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistEmail *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistEmail";
  
  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 ;
  FIX::RegistEmail *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistEmail";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistEmail" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistEmail" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistEmail'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistEmail(FIX::RegistEmail *arg1) {
    delete arg1;
}

swig_class cStreamAsgnReqID;

SWIGINTERN VALUE
_wrap_new_StreamAsgnReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StreamAsgnReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqID";
  
  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 ;
  FIX::StreamAsgnReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StreamAsgnReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StreamAsgnReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StreamAsgnReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnReqID(FIX::StreamAsgnReqID *arg1) {
    delete arg1;
}

swig_class cCPProgram;

SWIGINTERN VALUE
_wrap_new_CPProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CPProgram *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CPProgram";
  
  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 ;
  FIX::CPProgram *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CPProgram";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CPProgram" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CPProgram" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CPProgram'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CPProgram(FIX::CPProgram *arg1) {
    delete arg1;
}

swig_class cConfirmReqID;

SWIGINTERN VALUE
_wrap_new_ConfirmReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ConfirmReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmReqID";
  
  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 ;
  FIX::ConfirmReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ConfirmReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfirmReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfirmReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmReqID(FIX::ConfirmReqID *arg1) {
    delete arg1;
}

swig_class cAltMDSourceID;

SWIGINTERN VALUE
_wrap_new_AltMDSourceID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AltMDSourceID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AltMDSourceID";
  
  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 ;
  FIX::AltMDSourceID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AltMDSourceID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AltMDSourceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AltMDSourceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AltMDSourceID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AltMDSourceID(FIX::AltMDSourceID *arg1) {
    delete arg1;
}

swig_class cNoOrders;

SWIGINTERN VALUE
_wrap_new_NoOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoOrders *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOrders";
  
  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 ;
  FIX::NoOrders *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOrders";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoOrders'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOrders(FIX::NoOrders *arg1) {
    delete arg1;
}

swig_class cCashDistribAgentAcctName;

SWIGINTERN VALUE
_wrap_new_CashDistribAgentAcctName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashDistribAgentAcctName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctName";
  
  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 ;
  FIX::CashDistribAgentAcctName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribAgentAcctName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashDistribAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashDistribAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashDistribAgentAcctName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribAgentAcctName(FIX::CashDistribAgentAcctName *arg1) {
    delete arg1;
}

swig_class cNoContextPartySubIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoContextPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoContextPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContextPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoContextPartySubIDs *)new FIX::NoContextPartySubIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoContextPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoContextPartySubIDs__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_NoContextPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoContextPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoContextPartySubIDs(FIX::NoContextPartySubIDs *arg1) {
    delete arg1;
}

swig_class cUndlyInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UndlyInstrumentPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyIDSource";
  
  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 ;
  FIX::UndlyInstrumentPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::UndlyInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UndlyInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UndlyInstrumentPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartyIDSource(FIX::UndlyInstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class cUnderlyingSettlMethod;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSettlMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlMethod";
  
  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 ;
  FIX::UnderlyingSettlMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSettlMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSettlMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSettlMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlMethod(FIX::UnderlyingSettlMethod *arg1) {
    delete arg1;
}

swig_class cNoMDEntryTypes;

SWIGINTERN VALUE
_wrap_new_NoMDEntryTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMDEntryTypes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntryTypes";
  
  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 ;
  FIX::NoMDEntryTypes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntryTypes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMDEntryTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMDEntryTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMDEntryTypes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMDEntryTypes(FIX::NoMDEntryTypes *arg1) {
    delete arg1;
}

swig_class cMDEntryForwardPoints;

SWIGINTERN VALUE
_wrap_new_MDEntryForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryForwardPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryForwardPoints";
  
  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 ;
  FIX::MDEntryForwardPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryForwardPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDEntryForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryForwardPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryForwardPoints(FIX::MDEntryForwardPoints *arg1) {
    delete arg1;
}

swig_class cPosReqType;

SWIGINTERN VALUE
_wrap_new_PosReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosReqType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqType";
  
  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 ;
  FIX::PosReqType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosReqType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqType(FIX::PosReqType *arg1) {
    delete arg1;
}

swig_class cMassStatusReqType;

SWIGINTERN VALUE
_wrap_new_MassStatusReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassStatusReqType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqType";
  
  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 ;
  FIX::MassStatusReqType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassStatusReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassStatusReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassStatusReqType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassStatusReqType(FIX::MassStatusReqType *arg1) {
    delete arg1;
}

swig_class cTradeOriginationDate;

SWIGINTERN VALUE
_wrap_new_TradeOriginationDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeOriginationDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeOriginationDate";
  
  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 ;
  FIX::TradeOriginationDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeOriginationDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradeOriginationDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeOriginationDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeOriginationDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeOriginationDate(FIX::TradeOriginationDate *arg1) {
    delete arg1;
}

swig_class cSettlPrice;

SWIGINTERN VALUE
_wrap_new_SettlPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPrice";
  
  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 ;
  FIX::SettlPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPrice(FIX::SettlPrice *arg1) {
    delete arg1;
}

swig_class cSecuritySettlAgentAcctName;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentAcctName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecuritySettlAgentAcctName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctName";
  
  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 ;
  FIX::SecuritySettlAgentAcctName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentAcctName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecuritySettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecuritySettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecuritySettlAgentAcctName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentAcctName(FIX::SecuritySettlAgentAcctName *arg1) {
    delete arg1;
}

swig_class cRiskInstrumentMultiplier;

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


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

SWIGINTERN VALUE
_wrap_new_RiskInstrumentMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  FIX::RiskInstrumentMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskInstrumentMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::RiskInstrumentMultiplier *)new FIX::RiskInstrumentMultiplier((FIX::FLOAT const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskInstrumentMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskInstrumentMultiplier__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_RiskInstrumentMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskInstrumentMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskInstrumentMultiplier(FIX::RiskInstrumentMultiplier *arg1) {
    delete arg1;
}

swig_class cNoDerivativeEvents;

SWIGINTERN VALUE
_wrap_new_NoDerivativeEvents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDerivativeEvents *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeEvents";
  
  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 ;
  FIX::NoDerivativeEvents *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeEvents";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoDerivativeEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDerivativeEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDerivativeEvents'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeEvents(FIX::NoDerivativeEvents *arg1) {
    delete arg1;
}

swig_class cUnderlyingEndPrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingEndPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingEndPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndPrice";
  
  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 ;
  FIX::UnderlyingEndPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingEndPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingEndPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingEndPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingEndPrice(FIX::UnderlyingEndPrice *arg1) {
    delete arg1;
}

swig_class cSubscriptionRequestType;

SWIGINTERN VALUE
_wrap_new_SubscriptionRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SubscriptionRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SubscriptionRequestType";
  
  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 ;
  FIX::SubscriptionRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SubscriptionRequestType";
  
  if ((argc < 1) || (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), "in method '" "FIX::SubscriptionRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SubscriptionRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SubscriptionRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SubscriptionRequestType(FIX::SubscriptionRequestType *arg1) {
    delete arg1;
}

swig_class cTotalNumSecurityTypes;

SWIGINTERN VALUE
_wrap_new_TotalNumSecurityTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalNumSecurityTypes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurityTypes";
  
  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 ;
  FIX::TotalNumSecurityTypes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumSecurityTypes";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotalNumSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalNumSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalNumSecurityTypes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNumSecurityTypes(FIX::TotalNumSecurityTypes *arg1) {
    delete arg1;
}

swig_class cNewsCategory;

SWIGINTERN VALUE
_wrap_new_NewsCategory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NewsCategory *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsCategory";
  
  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 ;
  FIX::NewsCategory *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsCategory";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NewsCategory" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NewsCategory" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NewsCategory'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsCategory(FIX::NewsCategory *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegPutOrCall;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegPutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegPutOrCall *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegPutOrCall";
  
  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 ;
  FIX::UnderlyingLegPutOrCall *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegPutOrCall";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegPutOrCall'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegPutOrCall(FIX::UnderlyingLegPutOrCall *arg1) {
    delete arg1;
}

swig_class cURLLink;

SWIGINTERN VALUE
_wrap_new_URLLink__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::URLLink *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::URLLink";
  
  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 ;
  FIX::URLLink *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::URLLink";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::URLLink" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::URLLink" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_URLLink'");
  return Qnil;
}


SWIGINTERN void
free_FIX_URLLink(FIX::URLLink *arg1) {
    delete arg1;
}

swig_class cNoInstrumentPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoInstrumentPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoInstrumentPartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentPartySubIDs";
  
  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 ;
  FIX::NoInstrumentPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoInstrumentPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoInstrumentPartySubIDs(FIX::NoInstrumentPartySubIDs *arg1) {
    delete arg1;
}

swig_class cUnderlyingCurrentValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingCurrentValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCurrentValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrentValue";
  
  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 ;
  FIX::UnderlyingCurrentValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrentValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCurrentValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCurrentValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCurrentValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCurrentValue(FIX::UnderlyingCurrentValue *arg1) {
    delete arg1;
}

swig_class cInterestAccrualDate;

SWIGINTERN VALUE
_wrap_new_InterestAccrualDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InterestAccrualDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InterestAccrualDate";
  
  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 ;
  FIX::InterestAccrualDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InterestAccrualDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::InterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InterestAccrualDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InterestAccrualDate(FIX::InterestAccrualDate *arg1) {
    delete arg1;
}

swig_class cFutSettDate2;

SWIGINTERN VALUE
_wrap_new_FutSettDate2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FutSettDate2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate2";
  
  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 ;
  FIX::FutSettDate2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FutSettDate2";
  
  if ((argc < 1) || (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), "in method '" "FIX::FutSettDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FutSettDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FutSettDate2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FutSettDate2(FIX::FutSettDate2 *arg1) {
    delete arg1;
}

swig_class cNoClearingInstructions;

SWIGINTERN VALUE
_wrap_new_NoClearingInstructions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoClearingInstructions *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoClearingInstructions";
  
  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 ;
  FIX::NoClearingInstructions *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoClearingInstructions";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoClearingInstructions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoClearingInstructions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoClearingInstructions'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoClearingInstructions(FIX::NoClearingInstructions *arg1) {
    delete arg1;
}

swig_class cUnderlyingCurrency;

SWIGINTERN VALUE
_wrap_new_UnderlyingCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrency";
  
  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 ;
  FIX::UnderlyingCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCurrency(FIX::UnderlyingCurrency *arg1) {
    delete arg1;
}

swig_class cLegInterestAccrualDate;

SWIGINTERN VALUE
_wrap_new_LegInterestAccrualDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegInterestAccrualDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegInterestAccrualDate";
  
  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 ;
  FIX::LegInterestAccrualDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegInterestAccrualDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegInterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegInterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegInterestAccrualDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegInterestAccrualDate(FIX::LegInterestAccrualDate *arg1) {
    delete arg1;
}

swig_class cNewPassword;

SWIGINTERN VALUE
_wrap_new_NewPassword__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NewPassword *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewPassword";
  
  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 ;
  FIX::NewPassword *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewPassword";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NewPassword" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NewPassword" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NewPassword'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NewPassword(FIX::NewPassword *arg1) {
    delete arg1;
}

swig_class cRedemptionDate;

SWIGINTERN VALUE
_wrap_new_RedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RedemptionDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RedemptionDate";
  
  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 ;
  FIX::RedemptionDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RedemptionDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::RedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RedemptionDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RedemptionDate(FIX::RedemptionDate *arg1) {
    delete arg1;
}

swig_class cRefApplLastSeqNum;

SWIGINTERN VALUE
_wrap_new_RefApplLastSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefApplLastSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplLastSeqNum";
  
  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 ;
  FIX::RefApplLastSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplLastSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::RefApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefApplLastSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplLastSeqNum(FIX::RefApplLastSeqNum *arg1) {
    delete arg1;
}

swig_class cStartCash;

SWIGINTERN VALUE
_wrap_new_StartCash__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StartCash *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartCash";
  
  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 ;
  FIX::StartCash *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartCash";
  
  if ((argc < 1) || (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), "in method '" "FIX::StartCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StartCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StartCash'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StartCash(FIX::StartCash *arg1) {
    delete arg1;
}

swig_class cMaxMessageSize;

SWIGINTERN VALUE
_wrap_new_MaxMessageSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaxMessageSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxMessageSize";
  
  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 ;
  FIX::MaxMessageSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxMessageSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaxMessageSize" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaxMessageSize" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaxMessageSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxMessageSize(FIX::MaxMessageSize *arg1) {
    delete arg1;
}

swig_class cOfferForwardPoints;

SWIGINTERN VALUE
_wrap_new_OfferForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OfferForwardPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints";
  
  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 ;
  FIX::OfferForwardPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferForwardPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::OfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OfferForwardPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferForwardPoints(FIX::OfferForwardPoints *arg1) {
    delete arg1;
}

swig_class cIOIQty;

SWIGINTERN VALUE
_wrap_new_IOIQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQty";
  
  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 ;
  FIX::IOIQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQty";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIQty(FIX::IOIQty *arg1) {
    delete arg1;
}

swig_class cLastQty;

SWIGINTERN VALUE
_wrap_new_LastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastQty";
  
  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 ;
  FIX::LastQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastQty(FIX::LastQty *arg1) {
    delete arg1;
}

swig_class cApplResponseError;

SWIGINTERN VALUE
_wrap_new_ApplResponseError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplResponseError *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseError";
  
  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 ;
  FIX::ApplResponseError *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseError";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplResponseError" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplResponseError" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplResponseError'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResponseError(FIX::ApplResponseError *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecurityType;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityType";
  
  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 ;
  FIX::UnderlyingLegSecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityType(FIX::UnderlyingLegSecurityType *arg1) {
    delete arg1;
}

swig_class cDerivativePriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_DerivativePriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativePriceUnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasure";
  
  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 ;
  FIX::DerivativePriceUnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativePriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativePriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativePriceUnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePriceUnitOfMeasure(FIX::DerivativePriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cTriggerPriceDirection;

SWIGINTERN VALUE
_wrap_new_TriggerPriceDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerPriceDirection *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceDirection";
  
  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 ;
  FIX::TriggerPriceDirection *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceDirection";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerPriceDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerPriceDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerPriceDirection'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPriceDirection(FIX::TriggerPriceDirection *arg1) {
    delete arg1;
}

swig_class cPositionCurrency;

SWIGINTERN VALUE
_wrap_new_PositionCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PositionCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionCurrency";
  
  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 ;
  FIX::PositionCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionCurrency";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PositionCurrency" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PositionCurrency" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PositionCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PositionCurrency(FIX::PositionCurrency *arg1) {
    delete arg1;
}

swig_class cMessageEventSource;

SWIGINTERN VALUE
_wrap_new_MessageEventSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MessageEventSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageEventSource";
  
  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 ;
  FIX::MessageEventSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageEventSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MessageEventSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MessageEventSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MessageEventSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MessageEventSource(FIX::MessageEventSource *arg1) {
    delete arg1;
}

swig_class cCollInquiryID;

SWIGINTERN VALUE
_wrap_new_CollInquiryID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollInquiryID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryID";
  
  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 ;
  FIX::CollInquiryID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollInquiryID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollInquiryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollInquiryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollInquiryID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollInquiryID(FIX::CollInquiryID *arg1) {
    delete arg1;
}

swig_class cUnderlyingStartValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingStartValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingStartValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStartValue";
  
  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 ;
  FIX::UnderlyingStartValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStartValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingStartValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingStartValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingStartValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStartValue(FIX::UnderlyingStartValue *arg1) {
    delete arg1;
}

swig_class cLastLiquidityInd;

SWIGINTERN VALUE
_wrap_new_LastLiquidityInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastLiquidityInd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastLiquidityInd";
  
  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 ;
  FIX::LastLiquidityInd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastLiquidityInd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LastLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastLiquidityInd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastLiquidityInd(FIX::LastLiquidityInd *arg1) {
    delete arg1;
}

swig_class cSecurityID;

SWIGINTERN VALUE
_wrap_new_SecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityID";
  
  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 ;
  FIX::SecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityID(FIX::SecurityID *arg1) {
    delete arg1;
}

swig_class cNoMDEntries;

SWIGINTERN VALUE
_wrap_new_NoMDEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMDEntries *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntries";
  
  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 ;
  FIX::NoMDEntries *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDEntries";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMDEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMDEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMDEntries'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMDEntries(FIX::NoMDEntries *arg1) {
    delete arg1;
}

swig_class cNoPartyListResponseTypes;

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


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

SWIGINTERN VALUE
_wrap_new_NoPartyListResponseTypes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyListResponseTypes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyListResponseTypes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPartyListResponseTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPartyListResponseTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPartyListResponseTypes *)new FIX::NoPartyListResponseTypes((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPartyListResponseTypes(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPartyListResponseTypes__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_NoPartyListResponseTypes__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPartyListResponseTypes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartyListResponseTypes(FIX::NoPartyListResponseTypes *arg1) {
    delete arg1;
}

swig_class cStrikePriceDeterminationMethod;

SWIGINTERN VALUE
_wrap_new_StrikePriceDeterminationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikePriceDeterminationMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceDeterminationMethod";
  
  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 ;
  FIX::StrikePriceDeterminationMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceDeterminationMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StrikePriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikePriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikePriceDeterminationMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePriceDeterminationMethod(FIX::StrikePriceDeterminationMethod *arg1) {
    delete arg1;
}

swig_class cEndDate;

SWIGINTERN VALUE
_wrap_new_EndDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EndDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndDate";
  
  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 ;
  FIX::EndDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::EndDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EndDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EndDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EndDate(FIX::EndDate *arg1) {
    delete arg1;
}

swig_class cCashOutstanding;

SWIGINTERN VALUE
_wrap_new_CashOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashOutstanding *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashOutstanding";
  
  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 ;
  FIX::CashOutstanding *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashOutstanding";
  
  if ((argc < 1) || (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), "in method '" "FIX::CashOutstanding" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashOutstanding" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashOutstanding'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashOutstanding(FIX::CashOutstanding *arg1) {
    delete arg1;
}

swig_class cMDReqID;

SWIGINTERN VALUE
_wrap_new_MDReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReqID";
  
  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 ;
  FIX::MDReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDReqID(FIX::MDReqID *arg1) {
    delete arg1;
}

swig_class cIOIRefID;

SWIGINTERN VALUE
_wrap_new_IOIRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIRefID";
  
  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 ;
  FIX::IOIRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IOIRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIRefID(FIX::IOIRefID *arg1) {
    delete arg1;
}

swig_class cNoContextPartyIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoContextPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoContextPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContextPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoContextPartyIDs *)new FIX::NoContextPartyIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoContextPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoContextPartyIDs__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_NoContextPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoContextPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoContextPartyIDs(FIX::NoContextPartyIDs *arg1) {
    delete arg1;
}

swig_class cTargetStrategy;

SWIGINTERN VALUE
_wrap_new_TargetStrategy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetStrategy *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategy";
  
  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 ;
  FIX::TargetStrategy *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategy";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TargetStrategy" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetStrategy" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetStrategy'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetStrategy(FIX::TargetStrategy *arg1) {
    delete arg1;
}

swig_class cConfirmRefID;

SWIGINTERN VALUE
_wrap_new_ConfirmRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ConfirmRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRefID";
  
  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 ;
  FIX::ConfirmRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ConfirmRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfirmRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfirmRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmRefID(FIX::ConfirmRefID *arg1) {
    delete arg1;
}

swig_class cSellerDays;

SWIGINTERN VALUE
_wrap_new_SellerDays__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SellerDays *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SellerDays";
  
  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 ;
  FIX::SellerDays *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SellerDays";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SellerDays" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SellerDays" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SellerDays'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SellerDays(FIX::SellerDays *arg1) {
    delete arg1;
}

swig_class cDueToRelated;

SWIGINTERN VALUE
_wrap_new_DueToRelated__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DueToRelated *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DueToRelated";
  
  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 ;
  FIX::DueToRelated *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DueToRelated";
  
  if ((argc < 1) || (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), "in method '" "FIX::DueToRelated" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DueToRelated" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DueToRelated'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DueToRelated(FIX::DueToRelated *arg1) {
    delete arg1;
}

swig_class cSecondaryTradingReferencePrice;

SWIGINTERN VALUE
_wrap_new_SecondaryTradingReferencePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryTradingReferencePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradingReferencePrice";
  
  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 ;
  FIX::SecondaryTradingReferencePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradingReferencePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecondaryTradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryTradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryTradingReferencePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradingReferencePrice(FIX::SecondaryTradingReferencePrice *arg1) {
    delete arg1;
}

swig_class cNoMDFeedTypes;

SWIGINTERN VALUE
_wrap_new_NoMDFeedTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMDFeedTypes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDFeedTypes";
  
  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 ;
  FIX::NoMDFeedTypes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMDFeedTypes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMDFeedTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMDFeedTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMDFeedTypes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMDFeedTypes(FIX::NoMDFeedTypes *arg1) {
    delete arg1;
}

swig_class cUnderlyingInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingInstrumentPartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubIDType";
  
  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 ;
  FIX::UnderlyingInstrumentPartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingInstrumentPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartySubIDType(FIX::UnderlyingInstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class cTradSesCloseTime;

SWIGINTERN VALUE
_wrap_new_TradSesCloseTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesCloseTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  
  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 ;
  FIX::TradSesCloseTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  
  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), "in method '" "FIX::TradSesCloseTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TradSesCloseTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TradSesCloseTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesCloseTime";
  
  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), "in method '" "FIX::TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TradSesCloseTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesCloseTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesCloseTime(FIX::TradSesCloseTime *arg1) {
    delete arg1;
}

swig_class cContractSettlMonth;

SWIGINTERN VALUE
_wrap_new_ContractSettlMonth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContractSettlMonth *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractSettlMonth";
  
  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 ;
  FIX::ContractSettlMonth *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractSettlMonth";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContractSettlMonth'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContractSettlMonth(FIX::ContractSettlMonth *arg1) {
    delete arg1;
}

swig_class cDerivativeStrikePrice;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeStrikePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikePrice";
  
  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 ;
  FIX::DerivativeStrikePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeStrikePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikePrice(FIX::DerivativeStrikePrice *arg1) {
    delete arg1;
}

swig_class cTriggerSecurityDesc;

SWIGINTERN VALUE
_wrap_new_TriggerSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityDesc";
  
  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 ;
  FIX::TriggerSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TriggerSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSecurityDesc(FIX::TriggerSecurityDesc *arg1) {
    delete arg1;
}

swig_class cUnderlyingCashType;

SWIGINTERN VALUE
_wrap_new_UnderlyingCashType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCashType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashType";
  
  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 ;
  FIX::UnderlyingCashType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCashType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingCashType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCashType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCashType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCashType(FIX::UnderlyingCashType *arg1) {
    delete arg1;
}

swig_class cNoMiscFees;

SWIGINTERN VALUE
_wrap_new_NoMiscFees__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMiscFees *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMiscFees";
  
  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 ;
  FIX::NoMiscFees *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMiscFees";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMiscFees" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMiscFees" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMiscFees'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMiscFees(FIX::NoMiscFees *arg1) {
    delete arg1;
}

swig_class cCustOrderCapacity;

SWIGINTERN VALUE
_wrap_new_CustOrderCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CustOrderCapacity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustOrderCapacity";
  
  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 ;
  FIX::CustOrderCapacity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustOrderCapacity";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CustOrderCapacity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CustOrderCapacity(FIX::CustOrderCapacity *arg1) {
    delete arg1;
}

swig_class cRiskSecurityExchange;

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


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

SWIGINTERN VALUE
_wrap_new_RiskSecurityExchange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::EXCHANGE *arg1 = 0 ;
  FIX::RiskSecurityExchange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskSecurityExchange";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  result = (FIX::RiskSecurityExchange *)new FIX::RiskSecurityExchange((FIX::EXCHANGE const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskSecurityExchange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityExchange__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_RiskSecurityExchange__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityExchange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityExchange(FIX::RiskSecurityExchange *arg1) {
    delete arg1;
}

swig_class cLegAllocSettlCurrency;

SWIGINTERN VALUE
_wrap_new_LegAllocSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegAllocSettlCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocSettlCurrency";
  
  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 ;
  FIX::LegAllocSettlCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocSettlCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegAllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegAllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegAllocSettlCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocSettlCurrency(FIX::LegAllocSettlCurrency *arg1) {
    delete arg1;
}

swig_class cUnderlyingAdjustedQuantity;

SWIGINTERN VALUE
_wrap_new_UnderlyingAdjustedQuantity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingAdjustedQuantity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAdjustedQuantity";
  
  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 ;
  FIX::UnderlyingAdjustedQuantity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAdjustedQuantity";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingAdjustedQuantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingAdjustedQuantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingAdjustedQuantity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingAdjustedQuantity(FIX::UnderlyingAdjustedQuantity *arg1) {
    delete arg1;
}

swig_class cOwnershipType;

SWIGINTERN VALUE
_wrap_new_OwnershipType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OwnershipType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OwnershipType";
  
  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 ;
  FIX::OwnershipType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OwnershipType";
  
  if ((argc < 1) || (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), "in method '" "FIX::OwnershipType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OwnershipType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OwnershipType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OwnershipType(FIX::OwnershipType *arg1) {
    delete arg1;
}

swig_class cMaxShow;

SWIGINTERN VALUE
_wrap_new_MaxShow__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaxShow *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxShow";
  
  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 ;
  FIX::MaxShow *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxShow";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaxShow" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaxShow" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaxShow'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxShow(FIX::MaxShow *arg1) {
    delete arg1;
}

swig_class cLegSecurityID;

SWIGINTERN VALUE
_wrap_new_LegSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityID";
  
  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 ;
  FIX::LegSecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityID(FIX::LegSecurityID *arg1) {
    delete arg1;
}

swig_class cEncodedSymbol;

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


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

SWIGINTERN VALUE
_wrap_new_EncodedSymbol__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  FIX::EncodedSymbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSymbol";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSymbol" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSymbol" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::EncodedSymbol *)new FIX::EncodedSymbol((FIX::DATA const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_EncodedSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_EncodedSymbol__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_EncodedSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSymbol(FIX::EncodedSymbol *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityDesc;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityDesc";
  
  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 ;
  FIX::DerivativeSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityDesc(FIX::DerivativeSecurityDesc *arg1) {
    delete arg1;
}

swig_class cUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_UnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasure";
  
  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 ;
  FIX::UnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnitOfMeasure(FIX::UnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cSecDefStatus;

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


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

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


SWIGINTERN VALUE _wrap_new_SecDefStatus(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SecDefStatus__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecDefStatus__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecDefStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecDefStatus(FIX::SecDefStatus *arg1) {
    delete arg1;
}

swig_class cQuantity;

SWIGINTERN VALUE
_wrap_new_Quantity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Quantity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Quantity";
  
  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 ;
  FIX::Quantity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Quantity";
  
  if ((argc < 1) || (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), "in method '" "FIX::Quantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Quantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Quantity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Quantity(FIX::Quantity *arg1) {
    delete arg1;
}

swig_class cNewsID;

SWIGINTERN VALUE
_wrap_new_NewsID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NewsID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsID";
  
  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 ;
  FIX::NewsID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NewsID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NewsID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NewsID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsID(FIX::NewsID *arg1) {
    delete arg1;
}

swig_class cUndlyInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UndlyInstrumentPartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubIDType";
  
  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 ;
  FIX::UndlyInstrumentPartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UndlyInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UndlyInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UndlyInstrumentPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartySubIDType(FIX::UndlyInstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class cSettleOnOpenFlag;

SWIGINTERN VALUE
_wrap_new_SettleOnOpenFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettleOnOpenFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettleOnOpenFlag";
  
  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 ;
  FIX::SettleOnOpenFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettleOnOpenFlag";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettleOnOpenFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettleOnOpenFlag(FIX::SettleOnOpenFlag *arg1) {
    delete arg1;
}

swig_class cLastUpdateTime;

SWIGINTERN VALUE
_wrap_new_LastUpdateTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastUpdateTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  
  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 ;
  FIX::LastUpdateTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  
  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), "in method '" "FIX::LastUpdateTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::LastUpdateTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::LastUpdateTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastUpdateTime";
  
  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), "in method '" "FIX::LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::LastUpdateTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastUpdateTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastUpdateTime(FIX::LastUpdateTime *arg1) {
    delete arg1;
}

swig_class cRepurchaseRate;

SWIGINTERN VALUE
_wrap_new_RepurchaseRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RepurchaseRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseRate";
  
  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 ;
  FIX::RepurchaseRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::RepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RepurchaseRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RepurchaseRate(FIX::RepurchaseRate *arg1) {
    delete arg1;
}

swig_class cRepurchaseTerm;

SWIGINTERN VALUE
_wrap_new_RepurchaseTerm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RepurchaseTerm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseTerm";
  
  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 ;
  FIX::RepurchaseTerm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepurchaseTerm";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RepurchaseTerm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RepurchaseTerm(FIX::RepurchaseTerm *arg1) {
    delete arg1;
}

swig_class cNestedPartyRole;

SWIGINTERN VALUE
_wrap_new_NestedPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NestedPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyRole";
  
  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 ;
  FIX::NestedPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NestedPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NestedPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NestedPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartyRole(FIX::NestedPartyRole *arg1) {
    delete arg1;
}

swig_class cSecondaryExecID;

SWIGINTERN VALUE
_wrap_new_SecondaryExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryExecID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryExecID";
  
  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 ;
  FIX::SecondaryExecID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryExecID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryExecID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryExecID(FIX::SecondaryExecID *arg1) {
    delete arg1;
}

swig_class cPool;

SWIGINTERN VALUE
_wrap_new_Pool__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Pool *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Pool";
  
  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 ;
  FIX::Pool *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Pool";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Pool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Pool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Pool'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Pool(FIX::Pool *arg1) {
    delete arg1;
}

swig_class cNoTickRules;

SWIGINTERN VALUE
_wrap_new_NoTickRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTickRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTickRules";
  
  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 ;
  FIX::NoTickRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTickRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTickRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTickRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTickRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTickRules(FIX::NoTickRules *arg1) {
    delete arg1;
}

swig_class cVolatility;

SWIGINTERN VALUE
_wrap_new_Volatility__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Volatility *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Volatility";
  
  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 ;
  FIX::Volatility *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Volatility";
  
  if ((argc < 1) || (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), "in method '" "FIX::Volatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Volatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Volatility'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Volatility(FIX::Volatility *arg1) {
    delete arg1;
}

swig_class cPctAtRisk;

SWIGINTERN VALUE
_wrap_new_PctAtRisk__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PctAtRisk *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PctAtRisk";
  
  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 ;
  FIX::PctAtRisk *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PctAtRisk";
  
  if ((argc < 1) || (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), "in method '" "FIX::PctAtRisk" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PctAtRisk" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PctAtRisk'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PctAtRisk(FIX::PctAtRisk *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecurityExchange;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecurityExchange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityExchange";
  
  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 ;
  FIX::UnderlyingSecurityExchange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityExchange";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecurityExchange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityExchange(FIX::UnderlyingSecurityExchange *arg1) {
    delete arg1;
}

swig_class cLegStrikePrice;

SWIGINTERN VALUE
_wrap_new_LegStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegStrikePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStrikePrice";
  
  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 ;
  FIX::LegStrikePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStrikePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegStrikePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStrikePrice(FIX::LegStrikePrice *arg1) {
    delete arg1;
}

swig_class cSettlmntTyp;

SWIGINTERN VALUE
_wrap_new_SettlmntTyp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlmntTyp *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlmntTyp";
  
  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 ;
  FIX::SettlmntTyp *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlmntTyp";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlmntTyp'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlmntTyp(FIX::SettlmntTyp *arg1) {
    delete arg1;
}

swig_class cTradePublishIndicator;

SWIGINTERN VALUE
_wrap_new_TradePublishIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradePublishIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradePublishIndicator";
  
  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 ;
  FIX::TradePublishIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradePublishIndicator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradePublishIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradePublishIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradePublishIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradePublishIndicator(FIX::TradePublishIndicator *arg1) {
    delete arg1;
}

swig_class cApplResponseType;

SWIGINTERN VALUE
_wrap_new_ApplResponseType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplResponseType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseType";
  
  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 ;
  FIX::ApplResponseType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplResponseType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResponseType(FIX::ApplResponseType *arg1) {
    delete arg1;
}

swig_class cMDSubBookType;

SWIGINTERN VALUE
_wrap_new_MDSubBookType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDSubBookType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSubBookType";
  
  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 ;
  FIX::MDSubBookType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSubBookType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDSubBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDSubBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDSubBookType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDSubBookType(FIX::MDSubBookType *arg1) {
    delete arg1;
}

swig_class cUsername;

SWIGINTERN VALUE
_wrap_new_Username__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Username *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Username";
  
  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 ;
  FIX::Username *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Username";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Username" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Username" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Username'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Username(FIX::Username *arg1) {
    delete arg1;
}

swig_class cStandInstDbType;

SWIGINTERN VALUE
_wrap_new_StandInstDbType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StandInstDbType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbType";
  
  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 ;
  FIX::StandInstDbType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StandInstDbType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StandInstDbType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StandInstDbType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StandInstDbType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StandInstDbType(FIX::StandInstDbType *arg1) {
    delete arg1;
}

swig_class cRelatedContextPartyIDSource;

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


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

SWIGINTERN VALUE
_wrap_new_RelatedContextPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  FIX::RelatedContextPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelatedContextPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelatedContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelatedContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RelatedContextPartyIDSource *)new FIX::RelatedContextPartyIDSource((FIX::CHAR const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelatedContextPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedContextPartyIDSource__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_RelatedContextPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedContextPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedContextPartyIDSource(FIX::RelatedContextPartyIDSource *arg1) {
    delete arg1;
}

swig_class cQuoteEntryStatus;

SWIGINTERN VALUE
_wrap_new_QuoteEntryStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteEntryStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryStatus";
  
  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 ;
  FIX::QuoteEntryStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteEntryStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteEntryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteEntryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteEntryStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteEntryStatus(FIX::QuoteEntryStatus *arg1) {
    delete arg1;
}

swig_class cTriggerPriceType;

SWIGINTERN VALUE
_wrap_new_TriggerPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceType";
  
  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 ;
  FIX::TriggerPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceType";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPriceType(FIX::TriggerPriceType *arg1) {
    delete arg1;
}

swig_class cSideTrdSubTyp;

SWIGINTERN VALUE
_wrap_new_SideTrdSubTyp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideTrdSubTyp *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdSubTyp";
  
  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 ;
  FIX::SideTrdSubTyp *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdSubTyp";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideTrdSubTyp" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTrdSubTyp" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideTrdSubTyp'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdSubTyp(FIX::SideTrdSubTyp *arg1) {
    delete arg1;
}

swig_class cUnderlyingTradingSessionSubID;

SWIGINTERN VALUE
_wrap_new_UnderlyingTradingSessionSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingTradingSessionSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionSubID";
  
  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 ;
  FIX::UnderlyingTradingSessionSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingTradingSessionSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingTradingSessionSubID(FIX::UnderlyingTradingSessionSubID *arg1) {
    delete arg1;
}

swig_class cSettlInstReqRejCode;

SWIGINTERN VALUE
_wrap_new_SettlInstReqRejCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstReqRejCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqRejCode";
  
  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 ;
  FIX::SettlInstReqRejCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqRejCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlInstReqRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstReqRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstReqRejCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstReqRejCode(FIX::SettlInstReqRejCode *arg1) {
    delete arg1;
}

swig_class cMktBidPx;

SWIGINTERN VALUE
_wrap_new_MktBidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MktBidPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MktBidPx";
  
  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 ;
  FIX::MktBidPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MktBidPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::MktBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MktBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MktBidPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MktBidPx(FIX::MktBidPx *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSymbol;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSymbol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbol";
  
  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 ;
  FIX::UnderlyingLegSymbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSymbol";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSymbol(FIX::UnderlyingLegSymbol *arg1) {
    delete arg1;
}

swig_class cStrikeValue;

SWIGINTERN VALUE
_wrap_new_StrikeValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikeValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeValue";
  
  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 ;
  FIX::StrikeValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikeValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::StrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikeValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikeValue(FIX::StrikeValue *arg1) {
    delete arg1;
}

swig_class cUrgency;

SWIGINTERN VALUE
_wrap_new_Urgency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Urgency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Urgency";
  
  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 ;
  FIX::Urgency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Urgency";
  
  if ((argc < 1) || (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), "in method '" "FIX::Urgency" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Urgency" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Urgency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Urgency(FIX::Urgency *arg1) {
    delete arg1;
}

swig_class cAllocID;

SWIGINTERN VALUE
_wrap_new_AllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocID";
  
  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 ;
  FIX::AllocID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocID(FIX::AllocID *arg1) {
    delete arg1;
}

swig_class cNoPartyList;

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


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

SWIGINTERN VALUE
_wrap_new_NoPartyList__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyList *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyList";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPartyList" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPartyList" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPartyList *)new FIX::NoPartyList((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPartyList(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPartyList__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_NoPartyList__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPartyList'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartyList(FIX::NoPartyList *arg1) {
    delete arg1;
}

swig_class cUnderlyingDeliveryAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingDeliveryAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingDeliveryAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDeliveryAmount";
  
  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 ;
  FIX::UnderlyingDeliveryAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDeliveryAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingDeliveryAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingDeliveryAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingDeliveryAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingDeliveryAmount(FIX::UnderlyingDeliveryAmount *arg1) {
    delete arg1;
}

swig_class cSideQty;

SWIGINTERN VALUE
_wrap_new_SideQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideQty";
  
  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 ;
  FIX::SideQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideQty";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideQty(FIX::SideQty *arg1) {
    delete arg1;
}

swig_class cCollAsgnTransType;

SWIGINTERN VALUE
_wrap_new_CollAsgnTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollAsgnTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnTransType";
  
  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 ;
  FIX::CollAsgnTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnTransType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollAsgnTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollAsgnTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollAsgnTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnTransType(FIX::CollAsgnTransType *arg1) {
    delete arg1;
}

swig_class cThresholdAmount;

SWIGINTERN VALUE
_wrap_new_ThresholdAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ThresholdAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ThresholdAmount";
  
  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 ;
  FIX::ThresholdAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ThresholdAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::ThresholdAmount" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ThresholdAmount" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ThresholdAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ThresholdAmount(FIX::ThresholdAmount *arg1) {
    delete arg1;
}

swig_class cDefBidSize;

SWIGINTERN VALUE
_wrap_new_DefBidSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DefBidSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefBidSize";
  
  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 ;
  FIX::DefBidSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefBidSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::DefBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DefBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DefBidSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DefBidSize(FIX::DefBidSize *arg1) {
    delete arg1;
}

swig_class cLegStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_LegStateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegStateOrProvinceOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStateOrProvinceOfIssue";
  
  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 ;
  FIX::LegStateOrProvinceOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStateOrProvinceOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegStateOrProvinceOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStateOrProvinceOfIssue(FIX::LegStateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class cPaymentMethod;

SWIGINTERN VALUE
_wrap_new_PaymentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PaymentMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentMethod";
  
  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 ;
  FIX::PaymentMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PaymentMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PaymentMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PaymentMethod(FIX::PaymentMethod *arg1) {
    delete arg1;
}

swig_class cRiskCouponRate;

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


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

SWIGINTERN VALUE
_wrap_new_RiskCouponRate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RiskCouponRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskCouponRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::RiskCouponRate *)new FIX::RiskCouponRate((FIX::PERCENTAGE const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskCouponRate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskCouponRate__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_RiskCouponRate__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskCouponRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskCouponRate(FIX::RiskCouponRate *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegOptAttribute;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegOptAttribute *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegOptAttribute";
  
  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 ;
  FIX::UnderlyingLegOptAttribute *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegOptAttribute";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingLegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegOptAttribute'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegOptAttribute(FIX::UnderlyingLegOptAttribute *arg1) {
    delete arg1;
}

swig_class cLegVolatility;

SWIGINTERN VALUE
_wrap_new_LegVolatility__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegVolatility *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegVolatility";
  
  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 ;
  FIX::LegVolatility *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegVolatility";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegVolatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegVolatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegVolatility'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegVolatility(FIX::LegVolatility *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrAttribType;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrAttribType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrAttribType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribType";
  
  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 ;
  FIX::DerivativeInstrAttribType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrAttribType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrAttribType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrAttribType(FIX::DerivativeInstrAttribType *arg1) {
    delete arg1;
}

swig_class cDerivativeUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_DerivativeUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeUnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasureQty";
  
  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 ;
  FIX::DerivativeUnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeUnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeUnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeUnitOfMeasureQty(FIX::DerivativeUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cNoStatsIndicators;

SWIGINTERN VALUE
_wrap_new_NoStatsIndicators__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoStatsIndicators *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStatsIndicators";
  
  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 ;
  FIX::NoStatsIndicators *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStatsIndicators";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoStatsIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoStatsIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoStatsIndicators'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStatsIndicators(FIX::NoStatsIndicators *arg1) {
    delete arg1;
}

swig_class cTriggerPriceTypeScope;

SWIGINTERN VALUE
_wrap_new_TriggerPriceTypeScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerPriceTypeScope *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceTypeScope";
  
  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 ;
  FIX::TriggerPriceTypeScope *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPriceTypeScope";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerPriceTypeScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerPriceTypeScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerPriceTypeScope'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPriceTypeScope(FIX::TriggerPriceTypeScope *arg1) {
    delete arg1;
}

swig_class cLastNetworkResponseID;

SWIGINTERN VALUE
_wrap_new_LastNetworkResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastNetworkResponseID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastNetworkResponseID";
  
  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 ;
  FIX::LastNetworkResponseID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastNetworkResponseID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LastNetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastNetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastNetworkResponseID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastNetworkResponseID(FIX::LastNetworkResponseID *arg1) {
    delete arg1;
}

swig_class cUnderlyingSettlPriceType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSettlPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPriceType";
  
  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 ;
  FIX::UnderlyingSettlPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSettlPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlPriceType(FIX::UnderlyingSettlPriceType *arg1) {
    delete arg1;
}

swig_class cApplReportID;

SWIGINTERN VALUE
_wrap_new_ApplReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReportID";
  
  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 ;
  FIX::ApplReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReportID(FIX::ApplReportID *arg1) {
    delete arg1;
}

swig_class cPegLimitType;

SWIGINTERN VALUE
_wrap_new_PegLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegLimitType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegLimitType";
  
  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 ;
  FIX::PegLimitType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegLimitType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegLimitType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegLimitType(FIX::PegLimitType *arg1) {
    delete arg1;
}

swig_class cExecID;

SWIGINTERN VALUE
_wrap_new_ExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecID";
  
  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 ;
  FIX::ExecID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecID(FIX::ExecID *arg1) {
    delete arg1;
}

swig_class cSide;

SWIGINTERN VALUE
_wrap_new_Side__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Side *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Side";
  
  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 ;
  FIX::Side *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Side";
  
  if ((argc < 1) || (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), "in method '" "FIX::Side" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Side" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Side'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Side(FIX::Side *arg1) {
    delete arg1;
}

swig_class cUnderlyingLastPx;

SWIGINTERN VALUE
_wrap_new_UnderlyingLastPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLastPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastPx";
  
  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 ;
  FIX::UnderlyingLastPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLastPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLastPx(FIX::UnderlyingLastPx *arg1) {
    delete arg1;
}

swig_class cMarketDepth;

SWIGINTERN VALUE
_wrap_new_MarketDepth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarketDepth *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketDepth";
  
  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 ;
  FIX::MarketDepth *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketDepth";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MarketDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarketDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarketDepth'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketDepth(FIX::MarketDepth *arg1) {
    delete arg1;
}

swig_class cDiscretionOffset;

SWIGINTERN VALUE
_wrap_new_DiscretionOffset__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionOffset *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffset";
  
  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 ;
  FIX::DiscretionOffset *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffset";
  
  if ((argc < 1) || (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), "in method '" "FIX::DiscretionOffset" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionOffset" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionOffset'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionOffset(FIX::DiscretionOffset *arg1) {
    delete arg1;
}

swig_class cContAmtType;

SWIGINTERN VALUE
_wrap_new_ContAmtType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContAmtType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtType";
  
  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 ;
  FIX::ContAmtType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ContAmtType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContAmtType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContAmtType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContAmtType(FIX::ContAmtType *arg1) {
    delete arg1;
}

swig_class cMiscFeeCurr;

SWIGINTERN VALUE
_wrap_new_MiscFeeCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MiscFeeCurr *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeCurr";
  
  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 ;
  FIX::MiscFeeCurr *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeCurr";
  
  if ((argc < 1) || (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), "in method '" "FIX::MiscFeeCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MiscFeeCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MiscFeeCurr'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeCurr(FIX::MiscFeeCurr *arg1) {
    delete arg1;
}

swig_class cNoRiskLimits;

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


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

SWIGINTERN VALUE
_wrap_new_NoRiskLimits__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskLimits *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRiskLimits";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRiskLimits" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRiskLimits *)new FIX::NoRiskLimits((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRiskLimits(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRiskLimits__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_NoRiskLimits__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRiskLimits'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRiskLimits(FIX::NoRiskLimits *arg1) {
    delete arg1;
}

swig_class cAttachmentPoint;

SWIGINTERN VALUE
_wrap_new_AttachmentPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AttachmentPoint *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AttachmentPoint";
  
  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 ;
  FIX::AttachmentPoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AttachmentPoint";
  
  if ((argc < 1) || (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), "in method '" "FIX::AttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AttachmentPoint'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AttachmentPoint(FIX::AttachmentPoint *arg1) {
    delete arg1;
}

swig_class cOrderCategory;

SWIGINTERN VALUE
_wrap_new_OrderCategory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderCategory *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCategory";
  
  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 ;
  FIX::OrderCategory *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCategory";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderCategory" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderCategory" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderCategory'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderCategory(FIX::OrderCategory *arg1) {
    delete arg1;
}

swig_class cAdvTransType;

SWIGINTERN VALUE
_wrap_new_AdvTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AdvTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvTransType";
  
  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 ;
  FIX::AdvTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvTransType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AdvTransType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AdvTransType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AdvTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvTransType(FIX::AdvTransType *arg1) {
    delete arg1;
}

swig_class cWtAverageLiquidity;

SWIGINTERN VALUE
_wrap_new_WtAverageLiquidity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::WtAverageLiquidity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WtAverageLiquidity";
  
  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 ;
  FIX::WtAverageLiquidity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WtAverageLiquidity";
  
  if ((argc < 1) || (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), "in method '" "FIX::WtAverageLiquidity" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::WtAverageLiquidity" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_WtAverageLiquidity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_WtAverageLiquidity(FIX::WtAverageLiquidity *arg1) {
    delete arg1;
}

swig_class cQuoteSetValidUntilTime;

SWIGINTERN VALUE
_wrap_new_QuoteSetValidUntilTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteSetValidUntilTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  
  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 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  
  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), "in method '" "FIX::QuoteSetValidUntilTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetValidUntilTime";
  
  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), "in method '" "FIX::QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::QuoteSetValidUntilTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteSetValidUntilTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteSetValidUntilTime(FIX::QuoteSetValidUntilTime *arg1) {
    delete arg1;
}

swig_class cNoNested4PartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNested4PartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNested4PartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartyIDs";
  
  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 ;
  FIX::NoNested4PartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested4PartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNested4PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNested4PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNested4PartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested4PartyIDs(FIX::NoNested4PartyIDs *arg1) {
    delete arg1;
}

swig_class cLegPutOrCall;

SWIGINTERN VALUE
_wrap_new_LegPutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegPutOrCall *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPutOrCall";
  
  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 ;
  FIX::LegPutOrCall *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPutOrCall";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegPutOrCall'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPutOrCall(FIX::LegPutOrCall *arg1) {
    delete arg1;
}

swig_class cUserStatusText;

SWIGINTERN VALUE
_wrap_new_UserStatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UserStatusText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserStatusText";
  
  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 ;
  FIX::UserStatusText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserStatusText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UserStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UserStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UserStatusText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UserStatusText(FIX::UserStatusText *arg1) {
    delete arg1;
}

swig_class cNested2PartySubID;

SWIGINTERN VALUE
_wrap_new_Nested2PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested2PartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubID";
  
  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 ;
  FIX::Nested2PartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested2PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested2PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested2PartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartySubID(FIX::Nested2PartySubID *arg1) {
    delete arg1;
}

swig_class cEFPTrackingError;

SWIGINTERN VALUE
_wrap_new_EFPTrackingError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EFPTrackingError *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EFPTrackingError";
  
  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 ;
  FIX::EFPTrackingError *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EFPTrackingError";
  
  if ((argc < 1) || (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), "in method '" "FIX::EFPTrackingError" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EFPTrackingError" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EFPTrackingError'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EFPTrackingError(FIX::EFPTrackingError *arg1) {
    delete arg1;
}

swig_class cSideLiquidityInd;

SWIGINTERN VALUE
_wrap_new_SideLiquidityInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideLiquidityInd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideLiquidityInd";
  
  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 ;
  FIX::SideLiquidityInd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideLiquidityInd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideLiquidityInd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideLiquidityInd(FIX::SideLiquidityInd *arg1) {
    delete arg1;
}

swig_class cDerivativeMinPriceIncrement;

SWIGINTERN VALUE
_wrap_new_DerivativeMinPriceIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeMinPriceIncrement *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrement";
  
  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 ;
  FIX::DerivativeMinPriceIncrement *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMinPriceIncrement";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeMinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeMinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeMinPriceIncrement'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMinPriceIncrement(FIX::DerivativeMinPriceIncrement *arg1) {
    delete arg1;
}

swig_class cPublishTrdIndicator;

SWIGINTERN VALUE
_wrap_new_PublishTrdIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PublishTrdIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PublishTrdIndicator";
  
  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 ;
  FIX::PublishTrdIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PublishTrdIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::PublishTrdIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PublishTrdIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PublishTrdIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PublishTrdIndicator(FIX::PublishTrdIndicator *arg1) {
    delete arg1;
}

swig_class cInvestorCountryOfResidence;

SWIGINTERN VALUE
_wrap_new_InvestorCountryOfResidence__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InvestorCountryOfResidence *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvestorCountryOfResidence";
  
  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 ;
  FIX::InvestorCountryOfResidence *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InvestorCountryOfResidence";
  
  if ((argc < 1) || (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), "in method '" "FIX::InvestorCountryOfResidence" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InvestorCountryOfResidence" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InvestorCountryOfResidence'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InvestorCountryOfResidence(FIX::InvestorCountryOfResidence *arg1) {
    delete arg1;
}

swig_class cSideReasonCd;

SWIGINTERN VALUE
_wrap_new_SideReasonCd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideReasonCd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideReasonCd";
  
  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 ;
  FIX::SideReasonCd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideReasonCd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideReasonCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideReasonCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideReasonCd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideReasonCd(FIX::SideReasonCd *arg1) {
    delete arg1;
}

swig_class cMinPriceIncrement;

SWIGINTERN VALUE
_wrap_new_MinPriceIncrement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MinPriceIncrement *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrement";
  
  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 ;
  FIX::MinPriceIncrement *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrement";
  
  if ((argc < 1) || (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), "in method '" "FIX::MinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MinPriceIncrement'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MinPriceIncrement(FIX::MinPriceIncrement *arg1) {
    delete arg1;
}

swig_class cSecuritySettlAgentContactName;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentContactName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecuritySettlAgentContactName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactName";
  
  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 ;
  FIX::SecuritySettlAgentContactName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentContactName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecuritySettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecuritySettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecuritySettlAgentContactName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentContactName(FIX::SecuritySettlAgentContactName *arg1) {
    delete arg1;
}

swig_class cSecurityResponseType;

SWIGINTERN VALUE
_wrap_new_SecurityResponseType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityResponseType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseType";
  
  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 ;
  FIX::SecurityResponseType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityResponseType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityResponseType(FIX::SecurityResponseType *arg1) {
    delete arg1;
}

swig_class cLegBenchmarkCurvePoint;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurvePoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegBenchmarkCurvePoint *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurvePoint";
  
  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 ;
  FIX::LegBenchmarkCurvePoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurvePoint";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegBenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegBenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegBenchmarkCurvePoint'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkCurvePoint(FIX::LegBenchmarkCurvePoint *arg1) {
    delete arg1;
}

swig_class cClearingFirm;

SWIGINTERN VALUE
_wrap_new_ClearingFirm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClearingFirm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingFirm";
  
  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 ;
  FIX::ClearingFirm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingFirm";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClearingFirm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClearingFirm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClearingFirm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingFirm(FIX::ClearingFirm *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityIDSource;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecurityIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityIDSource(FIX::RelationshipRiskSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cSessionStatus;

SWIGINTERN VALUE
_wrap_new_SessionStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionStatus";
  
  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 ;
  FIX::SessionStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SessionStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SessionStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionStatus(FIX::SessionStatus *arg1) {
    delete arg1;
}

swig_class cTriggerSecurityID;

SWIGINTERN VALUE
_wrap_new_TriggerSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerSecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityID";
  
  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 ;
  FIX::TriggerSecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TriggerSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSecurityID(FIX::TriggerSecurityID *arg1) {
    delete arg1;
}

swig_class cTotNoAllocs;

SWIGINTERN VALUE
_wrap_new_TotNoAllocs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoAllocs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoAllocs";
  
  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 ;
  FIX::TotNoAllocs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoAllocs";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoAllocs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoAllocs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoAllocs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoAllocs(FIX::TotNoAllocs *arg1) {
    delete arg1;
}

swig_class cNoAltMDSource;

SWIGINTERN VALUE
_wrap_new_NoAltMDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoAltMDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAltMDSource";
  
  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 ;
  FIX::NoAltMDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAltMDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoAltMDSource" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoAltMDSource" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoAltMDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAltMDSource(FIX::NoAltMDSource *arg1) {
    delete arg1;
}

swig_class cAllocAccountType;

SWIGINTERN VALUE
_wrap_new_AllocAccountType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocAccountType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccountType";
  
  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 ;
  FIX::AllocAccountType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccountType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocAccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocAccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocAccountType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAccountType(FIX::AllocAccountType *arg1) {
    delete arg1;
}

swig_class cLastPx;

SWIGINTERN VALUE
_wrap_new_LastPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastPx";
  
  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 ;
  FIX::LastPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastPx(FIX::LastPx *arg1) {
    delete arg1;
}

swig_class cAllocTransType;

SWIGINTERN VALUE
_wrap_new_AllocTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocTransType";
  
  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 ;
  FIX::AllocTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocTransType";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocTransType(FIX::AllocTransType *arg1) {
    delete arg1;
}

swig_class cTotNoQuoteEntries;

SWIGINTERN VALUE
_wrap_new_TotNoQuoteEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoQuoteEntries *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoQuoteEntries";
  
  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 ;
  FIX::TotNoQuoteEntries *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoQuoteEntries";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoQuoteEntries'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoQuoteEntries(FIX::TotNoQuoteEntries *arg1) {
    delete arg1;
}

swig_class cMinBidSize;

SWIGINTERN VALUE
_wrap_new_MinBidSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MinBidSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinBidSize";
  
  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 ;
  FIX::MinBidSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinBidSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::MinBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MinBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MinBidSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MinBidSize(FIX::MinBidSize *arg1) {
    delete arg1;
}

swig_class cSettlBrkrCode;

SWIGINTERN VALUE
_wrap_new_SettlBrkrCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlBrkrCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlBrkrCode";
  
  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 ;
  FIX::SettlBrkrCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlBrkrCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlBrkrCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlBrkrCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlBrkrCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlBrkrCode(FIX::SettlBrkrCode *arg1) {
    delete arg1;
}

swig_class cCardHolderName;

SWIGINTERN VALUE
_wrap_new_CardHolderName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CardHolderName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardHolderName";
  
  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 ;
  FIX::CardHolderName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardHolderName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CardHolderName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CardHolderName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CardHolderName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CardHolderName(FIX::CardHolderName *arg1) {
    delete arg1;
}

swig_class cExpirationQtyType;

SWIGINTERN VALUE
_wrap_new_ExpirationQtyType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExpirationQtyType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpirationQtyType";
  
  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 ;
  FIX::ExpirationQtyType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpirationQtyType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExpirationQtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExpirationQtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExpirationQtyType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpirationQtyType(FIX::ExpirationQtyType *arg1) {
    delete arg1;
}

swig_class cEncodedUnderlyingSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedUnderlyingSecurityDescLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDescLen";
  
  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 ;
  FIX::EncodedUnderlyingSecurityDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingSecurityDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedUnderlyingSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedUnderlyingSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedUnderlyingSecurityDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingSecurityDescLen(FIX::EncodedUnderlyingSecurityDescLen *arg1) {
    delete arg1;
}

swig_class cQuoteReqID;

SWIGINTERN VALUE
_wrap_new_QuoteReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteReqID";
  
  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 ;
  FIX::QuoteReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteReqID(FIX::QuoteReqID *arg1) {
    delete arg1;
}

swig_class cNoRelatedPartyAltSubIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelatedPartyAltSubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedPartyAltSubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedPartyAltSubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelatedPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelatedPartyAltSubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelatedPartyAltSubIDs *)new FIX::NoRelatedPartyAltSubIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelatedPartyAltSubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelatedPartyAltSubIDs__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_NoRelatedPartyAltSubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelatedPartyAltSubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedPartyAltSubIDs(FIX::NoRelatedPartyAltSubIDs *arg1) {
    delete arg1;
}

swig_class cRiskProduct;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskProduct(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskProduct__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskProduct__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskProduct'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskProduct(FIX::RiskProduct *arg1) {
    delete arg1;
}

swig_class cRiskSecurityAltIDSource;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecurityAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityAltIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecurityAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityAltIDSource(FIX::RiskSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class cPriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_PriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceUnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasure";
  
  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 ;
  FIX::PriceUnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceUnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceUnitOfMeasure(FIX::PriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cTZTransactTime;

SWIGINTERN VALUE
_wrap_new_TZTransactTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TZTransactTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TZTransactTime";
  
  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 ;
  FIX::TZTransactTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TZTransactTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TZTransactTime" "', argument " "1"" of type '" "FIX::TZTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TZTransactTime" "', argument " "1"" of type '" "FIX::TZTIMESTAMP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TZTransactTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TZTransactTime(FIX::TZTransactTime *arg1) {
    delete arg1;
}

swig_class cAllocHandlInst;

SWIGINTERN VALUE
_wrap_new_AllocHandlInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocHandlInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocHandlInst";
  
  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 ;
  FIX::AllocHandlInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocHandlInst";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocHandlInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocHandlInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocHandlInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocHandlInst(FIX::AllocHandlInst *arg1) {
    delete arg1;
}

swig_class cUnderlyingInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingInstrumentPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyIDSource";
  
  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 ;
  FIX::UnderlyingInstrumentPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingInstrumentPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartyIDSource(FIX::UnderlyingInstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class cCurrencyRatio;

SWIGINTERN VALUE
_wrap_new_CurrencyRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CurrencyRatio *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CurrencyRatio";
  
  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 ;
  FIX::CurrencyRatio *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CurrencyRatio";
  
  if ((argc < 1) || (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), "in method '" "FIX::CurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CurrencyRatio'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CurrencyRatio(FIX::CurrencyRatio *arg1) {
    delete arg1;
}

swig_class cRefreshQty;

SWIGINTERN VALUE
_wrap_new_RefreshQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefreshQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefreshQty";
  
  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 ;
  FIX::RefreshQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefreshQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::RefreshQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefreshQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefreshQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefreshQty(FIX::RefreshQty *arg1) {
    delete arg1;
}

swig_class cTradeRequestStatus;

SWIGINTERN VALUE
_wrap_new_TradeRequestStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeRequestStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestStatus";
  
  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 ;
  FIX::TradeRequestStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeRequestStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeRequestStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeRequestStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeRequestStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeRequestStatus(FIX::TradeRequestStatus *arg1) {
    delete arg1;
}

swig_class cTrdRepIndicator;

SWIGINTERN VALUE
_wrap_new_TrdRepIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdRepIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRepIndicator";
  
  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 ;
  FIX::TrdRepIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRepIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::TrdRepIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdRepIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdRepIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRepIndicator(FIX::TrdRepIndicator *arg1) {
    delete arg1;
}

swig_class cMiscFeeAmt;

SWIGINTERN VALUE
_wrap_new_MiscFeeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MiscFeeAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeAmt";
  
  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 ;
  FIX::MiscFeeAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::MiscFeeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MiscFeeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MiscFeeAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeAmt(FIX::MiscFeeAmt *arg1) {
    delete arg1;
}

swig_class cTradSesOpenTime;

SWIGINTERN VALUE
_wrap_new_TradSesOpenTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesOpenTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  
  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 ;
  FIX::TradSesOpenTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  
  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), "in method '" "FIX::TradSesOpenTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TradSesOpenTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TradSesOpenTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesOpenTime";
  
  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), "in method '" "FIX::TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TradSesOpenTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesOpenTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesOpenTime(FIX::TradSesOpenTime *arg1) {
    delete arg1;
}

swig_class cPreallocMethod;

SWIGINTERN VALUE
_wrap_new_PreallocMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PreallocMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreallocMethod";
  
  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 ;
  FIX::PreallocMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreallocMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::PreallocMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PreallocMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PreallocMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PreallocMethod(FIX::PreallocMethod *arg1) {
    delete arg1;
}

swig_class cTaxAdvantageType;

SWIGINTERN VALUE
_wrap_new_TaxAdvantageType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TaxAdvantageType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TaxAdvantageType";
  
  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 ;
  FIX::TaxAdvantageType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TaxAdvantageType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TaxAdvantageType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TaxAdvantageType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TaxAdvantageType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TaxAdvantageType(FIX::TaxAdvantageType *arg1) {
    delete arg1;
}

swig_class cMessageEncoding;

SWIGINTERN VALUE
_wrap_new_MessageEncoding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MessageEncoding *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageEncoding";
  
  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 ;
  FIX::MessageEncoding *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageEncoding";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MessageEncoding" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MessageEncoding" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MessageEncoding'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MessageEncoding(FIX::MessageEncoding *arg1) {
    delete arg1;
}

swig_class cRiskPutOrCall;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskPutOrCall(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskPutOrCall__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskPutOrCall__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskPutOrCall'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskPutOrCall(FIX::RiskPutOrCall *arg1) {
    delete arg1;
}

swig_class cRiskSecurityGroup;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecurityGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityGroup__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecurityGroup__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityGroup'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityGroup(FIX::RiskSecurityGroup *arg1) {
    delete arg1;
}

swig_class cNoPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoPartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartySubIDs";
  
  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 ;
  FIX::NoPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartySubIDs(FIX::NoPartySubIDs *arg1) {
    delete arg1;
}

swig_class cSettlInstReqID;

SWIGINTERN VALUE
_wrap_new_SettlInstReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqID";
  
  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 ;
  FIX::SettlInstReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlInstReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstReqID(FIX::SettlInstReqID *arg1) {
    delete arg1;
}

swig_class cLegRepoCollateralSecurityType;

SWIGINTERN VALUE
_wrap_new_LegRepoCollateralSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegRepoCollateralSecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepoCollateralSecurityType";
  
  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::INT *arg1 = 0 ;
  FIX::LegRepoCollateralSecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepoCollateralSecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::LegRepoCollateralSecurityType *)new FIX::LegRepoCollateralSecurityType((FIX::INT 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__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRepoCollateralSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegRepoCollateralSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRepoCollateralSecurityType(FIX::LegRepoCollateralSecurityType *arg1) {
    delete arg1;
}

swig_class cAffectedSecondaryOrderID;

SWIGINTERN VALUE
_wrap_new_AffectedSecondaryOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AffectedSecondaryOrderID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffectedSecondaryOrderID";
  
  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 ;
  FIX::AffectedSecondaryOrderID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffectedSecondaryOrderID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AffectedSecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AffectedSecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AffectedSecondaryOrderID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AffectedSecondaryOrderID(FIX::AffectedSecondaryOrderID *arg1) {
    delete arg1;
}

swig_class cRiskSymbol;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSymbol(FIX::RiskSymbol *arg1) {
    delete arg1;
}

swig_class cDerivativeMaturityTime;

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeMaturityTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityTime";
  
  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 ;
  FIX::DerivativeMaturityTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeMaturityTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMaturityTime(FIX::DerivativeMaturityTime *arg1) {
    delete arg1;
}

swig_class cExpireTime;

SWIGINTERN VALUE
_wrap_new_ExpireTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExpireTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  
  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 ;
  FIX::ExpireTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  
  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), "in method '" "FIX::ExpireTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::ExpireTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::ExpireTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireTime";
  
  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), "in method '" "FIX::ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ExpireTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExpireTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpireTime(FIX::ExpireTime *arg1) {
    delete arg1;
}

swig_class cUnderlyingFactor;

SWIGINTERN VALUE
_wrap_new_UnderlyingFactor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingFactor *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFactor";
  
  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 ;
  FIX::UnderlyingFactor *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFactor";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingFactor'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFactor(FIX::UnderlyingFactor *arg1) {
    delete arg1;
}

swig_class cOrigOrdModTime;

SWIGINTERN VALUE
_wrap_new_OrigOrdModTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigOrdModTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  
  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 ;
  FIX::OrigOrdModTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  
  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), "in method '" "FIX::OrigOrdModTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::OrigOrdModTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::OrigOrdModTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigOrdModTime";
  
  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), "in method '" "FIX::OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::OrigOrdModTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigOrdModTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigOrdModTime(FIX::OrigOrdModTime *arg1) {
    delete arg1;
}

swig_class cNoTrdRepIndicators;

SWIGINTERN VALUE
_wrap_new_NoTrdRepIndicators__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTrdRepIndicators *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRepIndicators";
  
  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 ;
  FIX::NoTrdRepIndicators *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRepIndicators";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTrdRepIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTrdRepIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTrdRepIndicators'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTrdRepIndicators(FIX::NoTrdRepIndicators *arg1) {
    delete arg1;
}

swig_class cDerivativeMaturityDate;

SWIGINTERN VALUE
_wrap_new_DerivativeMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeMaturityDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityDate";
  
  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 ;
  FIX::DerivativeMaturityDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeMaturityDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeMaturityDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeMaturityDate(FIX::DerivativeMaturityDate *arg1) {
    delete arg1;
}

swig_class cDerivativeCFICode;

SWIGINTERN VALUE
_wrap_new_DerivativeCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeCFICode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCFICode";
  
  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 ;
  FIX::DerivativeCFICode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCFICode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeCFICode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeCFICode(FIX::DerivativeCFICode *arg1) {
    delete arg1;
}

swig_class cNested2PartySubIDType;

SWIGINTERN VALUE
_wrap_new_Nested2PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested2PartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubIDType";
  
  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 ;
  FIX::Nested2PartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested2PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested2PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested2PartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartySubIDType(FIX::Nested2PartySubIDType *arg1) {
    delete arg1;
}

swig_class cLegIOIQty;

SWIGINTERN VALUE
_wrap_new_LegIOIQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegIOIQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIOIQty";
  
  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 ;
  FIX::LegIOIQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIOIQty";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegIOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegIOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegIOIQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIOIQty(FIX::LegIOIQty *arg1) {
    delete arg1;
}

swig_class cExpireDate;

SWIGINTERN VALUE
_wrap_new_ExpireDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExpireDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireDate";
  
  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 ;
  FIX::ExpireDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpireDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExpireDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExpireDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExpireDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpireDate(FIX::ExpireDate *arg1) {
    delete arg1;
}

swig_class cRiskSecurityType;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityType(FIX::RiskSecurityType *arg1) {
    delete arg1;
}

swig_class cNoMatchRules;

SWIGINTERN VALUE
_wrap_new_NoMatchRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoMatchRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMatchRules";
  
  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 ;
  FIX::NoMatchRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoMatchRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoMatchRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoMatchRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoMatchRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoMatchRules(FIX::NoMatchRules *arg1) {
    delete arg1;
}

swig_class cApplEndSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplEndSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplEndSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplEndSeqNum";
  
  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 ;
  FIX::ApplEndSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplEndSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::ApplEndSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplEndSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplEndSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplEndSeqNum(FIX::ApplEndSeqNum *arg1) {
    delete arg1;
}

swig_class cEventPx;

SWIGINTERN VALUE
_wrap_new_EventPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EventPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventPx";
  
  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 ;
  FIX::EventPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::EventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EventPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EventPx(FIX::EventPx *arg1) {
    delete arg1;
}

swig_class cAsgnRptID;

SWIGINTERN VALUE
_wrap_new_AsgnRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AsgnRptID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AsgnRptID";
  
  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 ;
  FIX::AsgnRptID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AsgnRptID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AsgnRptID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AsgnRptID(FIX::AsgnRptID *arg1) {
    delete arg1;
}

swig_class cTimeInForce;

SWIGINTERN VALUE
_wrap_new_TimeInForce__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TimeInForce *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeInForce";
  
  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 ;
  FIX::TimeInForce *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeInForce";
  
  if ((argc < 1) || (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), "in method '" "FIX::TimeInForce" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TimeInForce" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TimeInForce'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeInForce(FIX::TimeInForce *arg1) {
    delete arg1;
}

swig_class cLowPx;

SWIGINTERN VALUE
_wrap_new_LowPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LowPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LowPx";
  
  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 ;
  FIX::LowPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LowPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::LowPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LowPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LowPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LowPx(FIX::LowPx *arg1) {
    delete arg1;
}

swig_class cIOIQualifier;

SWIGINTERN VALUE
_wrap_new_IOIQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIQualifier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQualifier";
  
  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 ;
  FIX::IOIQualifier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIQualifier";
  
  if ((argc < 1) || (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), "in method '" "FIX::IOIQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIQualifier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIQualifier(FIX::IOIQualifier *arg1) {
    delete arg1;
}

swig_class cWaveNo;

SWIGINTERN VALUE
_wrap_new_WaveNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::WaveNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WaveNo";
  
  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 ;
  FIX::WaveNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::WaveNo";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::WaveNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::WaveNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_WaveNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_WaveNo(FIX::WaveNo *arg1) {
    delete arg1;
}

swig_class cRiskSeniority;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSeniority(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSeniority__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSeniority__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSeniority'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSeniority(FIX::RiskSeniority *arg1) {
    delete arg1;
}

swig_class cStrikePriceBoundaryMethod;

SWIGINTERN VALUE
_wrap_new_StrikePriceBoundaryMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikePriceBoundaryMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryMethod";
  
  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 ;
  FIX::StrikePriceBoundaryMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StrikePriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikePriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikePriceBoundaryMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePriceBoundaryMethod(FIX::StrikePriceBoundaryMethod *arg1) {
    delete arg1;
}

swig_class cDerivativeIssueDate;

SWIGINTERN VALUE
_wrap_new_DerivativeIssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeIssueDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssueDate";
  
  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 ;
  FIX::DerivativeIssueDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeIssueDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeIssueDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeIssueDate(FIX::DerivativeIssueDate *arg1) {
    delete arg1;
}

swig_class cMiscFeeType;

SWIGINTERN VALUE
_wrap_new_MiscFeeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MiscFeeType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeType";
  
  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 ;
  FIX::MiscFeeType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MiscFeeType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MiscFeeType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MiscFeeType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeType(FIX::MiscFeeType *arg1) {
    delete arg1;
}

swig_class cQuoteID;

SWIGINTERN VALUE
_wrap_new_QuoteID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteID";
  
  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 ;
  FIX::QuoteID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteID(FIX::QuoteID *arg1) {
    delete arg1;
}

swig_class cRiskFlexibleIndicator;

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


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

SWIGINTERN VALUE
_wrap_new_RiskFlexibleIndicator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::BOOLEAN *arg1 = 0 ;
  FIX::RiskFlexibleIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskFlexibleIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskFlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  result = (FIX::RiskFlexibleIndicator *)new FIX::RiskFlexibleIndicator((FIX::BOOLEAN const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskFlexibleIndicator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskFlexibleIndicator__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_RiskFlexibleIndicator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskFlexibleIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskFlexibleIndicator(FIX::RiskFlexibleIndicator *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrumentPartyIDSource;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrumentPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyIDSource";
  
  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 ;
  FIX::DerivativeInstrumentPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrumentPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartyIDSource(FIX::DerivativeInstrumentPartyIDSource *arg1) {
    delete arg1;
}

swig_class cSettlObligID;

SWIGINTERN VALUE
_wrap_new_SettlObligID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlObligID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligID";
  
  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 ;
  FIX::SettlObligID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlObligID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlObligID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlObligID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligID(FIX::SettlObligID *arg1) {
    delete arg1;
}

swig_class cInstrAttribValue;

SWIGINTERN VALUE
_wrap_new_InstrAttribValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrAttribValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribValue";
  
  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 ;
  FIX::InstrAttribValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrAttribValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrAttribValue(FIX::InstrAttribValue *arg1) {
    delete arg1;
}

swig_class cLiquidityValue;

SWIGINTERN VALUE
_wrap_new_LiquidityValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LiquidityValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityValue";
  
  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 ;
  FIX::LiquidityValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::LiquidityValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LiquidityValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LiquidityValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityValue(FIX::LiquidityValue *arg1) {
    delete arg1;
}

swig_class cSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_SecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityIDSource";
  
  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 ;
  FIX::SecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityIDSource(FIX::SecurityIDSource *arg1) {
    delete arg1;
}

swig_class cNewsRefType;

SWIGINTERN VALUE
_wrap_new_NewsRefType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NewsRefType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsRefType";
  
  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 ;
  FIX::NewsRefType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewsRefType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NewsRefType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NewsRefType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NewsRefType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NewsRefType(FIX::NewsRefType *arg1) {
    delete arg1;
}

swig_class cNoOfLegUnderlyings;

SWIGINTERN VALUE
_wrap_new_NoOfLegUnderlyings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoOfLegUnderlyings *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOfLegUnderlyings";
  
  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 ;
  FIX::NoOfLegUnderlyings *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOfLegUnderlyings";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoOfLegUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoOfLegUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoOfLegUnderlyings'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOfLegUnderlyings(FIX::NoOfLegUnderlyings *arg1) {
    delete arg1;
}

swig_class cDerivativeEncodedSecurityDesc;

SWIGINTERN VALUE
_wrap_new_DerivativeEncodedSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeEncodedSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDesc";
  
  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 ;
  FIX::DerivativeEncodedSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeEncodedSecurityDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeEncodedSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeEncodedSecurityDesc(FIX::DerivativeEncodedSecurityDesc *arg1) {
    delete arg1;
}

swig_class cTriggerOrderType;

SWIGINTERN VALUE
_wrap_new_TriggerOrderType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerOrderType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerOrderType";
  
  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 ;
  FIX::TriggerOrderType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerOrderType";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerOrderType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerOrderType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerOrderType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerOrderType(FIX::TriggerOrderType *arg1) {
    delete arg1;
}

swig_class cUnderlyingDirtyPrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingDirtyPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingDirtyPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDirtyPrice";
  
  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 ;
  FIX::UnderlyingDirtyPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingDirtyPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingDirtyPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingDirtyPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingDirtyPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingDirtyPrice(FIX::UnderlyingDirtyPrice *arg1) {
    delete arg1;
}

swig_class cCrossType;

SWIGINTERN VALUE
_wrap_new_CrossType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CrossType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossType";
  
  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 ;
  FIX::CrossType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CrossType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CrossType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CrossType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossType(FIX::CrossType *arg1) {
    delete arg1;
}

swig_class cRepoCollateralSecurityType;

SWIGINTERN VALUE
_wrap_new_RepoCollateralSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RepoCollateralSecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepoCollateralSecurityType";
  
  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::INT *arg1 = 0 ;
  FIX::RepoCollateralSecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RepoCollateralSecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::RepoCollateralSecurityType *)new FIX::RepoCollateralSecurityType((FIX::INT 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__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RepoCollateralSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RepoCollateralSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RepoCollateralSecurityType(FIX::RepoCollateralSecurityType *arg1) {
    delete arg1;
}

swig_class cPassword;

SWIGINTERN VALUE
_wrap_new_Password__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Password *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Password";
  
  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 ;
  FIX::Password *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Password";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Password" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Password" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Password'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Password(FIX::Password *arg1) {
    delete arg1;
}

swig_class cOpenCloseSettleFlag;

SWIGINTERN VALUE
_wrap_new_OpenCloseSettleFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OpenCloseSettleFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettleFlag";
  
  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 ;
  FIX::OpenCloseSettleFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenCloseSettleFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::OpenCloseSettleFlag" "', argument " "1"" of type '" "FIX::MULTIPLEVALUESTRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OpenCloseSettleFlag" "', argument " "1"" of type '" "FIX::MULTIPLEVALUESTRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OpenCloseSettleFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenCloseSettleFlag(FIX::OpenCloseSettleFlag *arg1) {
    delete arg1;
}

swig_class cSubject;

SWIGINTERN VALUE
_wrap_new_Subject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Subject *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Subject";
  
  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 ;
  FIX::Subject *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Subject";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Subject" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Subject" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Subject'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Subject(FIX::Subject *arg1) {
    delete arg1;
}

swig_class cRefApplReqID;

SWIGINTERN VALUE
_wrap_new_RefApplReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefApplReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplReqID";
  
  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 ;
  FIX::RefApplReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefApplReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplReqID(FIX::RefApplReqID *arg1) {
    delete arg1;
}

swig_class cUnderlyingEndValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingEndValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingEndValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndValue";
  
  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 ;
  FIX::UnderlyingEndValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingEndValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingEndValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingEndValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingEndValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingEndValue(FIX::UnderlyingEndValue *arg1) {
    delete arg1;
}

swig_class cNewSeqNo;

SWIGINTERN VALUE
_wrap_new_NewSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NewSeqNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewSeqNo";
  
  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 ;
  FIX::NewSeqNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NewSeqNo";
  
  if ((argc < 1) || (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), "in method '" "FIX::NewSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NewSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NewSeqNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NewSeqNo(FIX::NewSeqNo *arg1) {
    delete arg1;
}

swig_class cOrigTradeHandlingInstr;

SWIGINTERN VALUE
_wrap_new_OrigTradeHandlingInstr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigTradeHandlingInstr *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeHandlingInstr";
  
  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 ;
  FIX::OrigTradeHandlingInstr *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeHandlingInstr";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrigTradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigTradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigTradeHandlingInstr'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTradeHandlingInstr(FIX::OrigTradeHandlingInstr *arg1) {
    delete arg1;
}

swig_class cDisplayHighQty;

SWIGINTERN VALUE
_wrap_new_DisplayHighQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DisplayHighQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayHighQty";
  
  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 ;
  FIX::DisplayHighQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayHighQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::DisplayHighQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DisplayHighQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DisplayHighQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayHighQty(FIX::DisplayHighQty *arg1) {
    delete arg1;
}

swig_class cMDBookType;

SWIGINTERN VALUE
_wrap_new_MDBookType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDBookType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDBookType";
  
  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 ;
  FIX::MDBookType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDBookType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDBookType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDBookType(FIX::MDBookType *arg1) {
    delete arg1;
}

swig_class cMarginExcess;

SWIGINTERN VALUE
_wrap_new_MarginExcess__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarginExcess *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarginExcess";
  
  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 ;
  FIX::MarginExcess *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarginExcess";
  
  if ((argc < 1) || (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), "in method '" "FIX::MarginExcess" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarginExcess" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarginExcess'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarginExcess(FIX::MarginExcess *arg1) {
    delete arg1;
}

swig_class cBasisPxType;

SWIGINTERN VALUE
_wrap_new_BasisPxType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BasisPxType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisPxType";
  
  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 ;
  FIX::BasisPxType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisPxType";
  
  if ((argc < 1) || (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), "in method '" "FIX::BasisPxType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BasisPxType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BasisPxType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BasisPxType(FIX::BasisPxType *arg1) {
    delete arg1;
}

swig_class cDlvyInst;

SWIGINTERN VALUE
_wrap_new_DlvyInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DlvyInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DlvyInst";
  
  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 ;
  FIX::DlvyInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DlvyInst";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DlvyInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DlvyInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DlvyInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DlvyInst(FIX::DlvyInst *arg1) {
    delete arg1;
}

swig_class cComplianceID;

SWIGINTERN VALUE
_wrap_new_ComplianceID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplianceID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplianceID";
  
  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 ;
  FIX::ComplianceID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplianceID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplianceID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplianceID(FIX::ComplianceID *arg1) {
    delete arg1;
}

swig_class cEmailThreadID;

SWIGINTERN VALUE
_wrap_new_EmailThreadID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EmailThreadID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EmailThreadID";
  
  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 ;
  FIX::EmailThreadID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EmailThreadID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::EmailThreadID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EmailThreadID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EmailThreadID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EmailThreadID(FIX::EmailThreadID *arg1) {
    delete arg1;
}

swig_class cContAmtCurr;

SWIGINTERN VALUE
_wrap_new_ContAmtCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContAmtCurr *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtCurr";
  
  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 ;
  FIX::ContAmtCurr *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContAmtCurr";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContAmtCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContAmtCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContAmtCurr'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContAmtCurr(FIX::ContAmtCurr *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityGroup;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityGroup(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityGroup__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecurityGroup__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityGroup'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityGroup(FIX::RelationshipRiskSecurityGroup *arg1) {
    delete arg1;
}

swig_class cComplexEventType;

SWIGINTERN VALUE
_wrap_new_ComplexEventType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventType";
  
  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 ;
  FIX::ComplexEventType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ComplexEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventType(FIX::ComplexEventType *arg1) {
    delete arg1;
}

swig_class cMassActionResponse;

SWIGINTERN VALUE
_wrap_new_MassActionResponse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassActionResponse *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionResponse";
  
  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 ;
  FIX::MassActionResponse *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassActionResponse";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassActionResponse" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassActionResponse" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassActionResponse'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassActionResponse(FIX::MassActionResponse *arg1) {
    delete arg1;
}

swig_class cUnderlyingIssueDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingIssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingIssueDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssueDate";
  
  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 ;
  FIX::UnderlyingIssueDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIssueDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingIssueDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingIssueDate(FIX::UnderlyingIssueDate *arg1) {
    delete arg1;
}

swig_class cSecurityRequestType;

SWIGINTERN VALUE
_wrap_new_SecurityRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestType";
  
  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 ;
  FIX::SecurityRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityRequestType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityRequestType(FIX::SecurityRequestType *arg1) {
    delete arg1;
}

swig_class cAllocInterestAtMaturity;

SWIGINTERN VALUE
_wrap_new_AllocInterestAtMaturity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocInterestAtMaturity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocInterestAtMaturity";
  
  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 ;
  FIX::AllocInterestAtMaturity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocInterestAtMaturity";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocInterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocInterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocInterestAtMaturity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocInterestAtMaturity(FIX::AllocInterestAtMaturity *arg1) {
    delete arg1;
}

swig_class cListRejectReason;

SWIGINTERN VALUE
_wrap_new_ListRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListRejectReason";
  
  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 ;
  FIX::ListRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListRejectReason(FIX::ListRejectReason *arg1) {
    delete arg1;
}

swig_class cDeskType;

SWIGINTERN VALUE
_wrap_new_DeskType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeskType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskType";
  
  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 ;
  FIX::DeskType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeskType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeskType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeskType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskType(FIX::DeskType *arg1) {
    delete arg1;
}

swig_class cSecondaryTradeReportID;

SWIGINTERN VALUE
_wrap_new_SecondaryTradeReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryTradeReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportID";
  
  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 ;
  FIX::SecondaryTradeReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryTradeReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradeReportID(FIX::SecondaryTradeReportID *arg1) {
    delete arg1;
}

swig_class cSettlType;

SWIGINTERN VALUE
_wrap_new_SettlType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlType";
  
  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 ;
  FIX::SettlType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlType(FIX::SettlType *arg1) {
    delete arg1;
}

swig_class cOpenClose;

SWIGINTERN VALUE
_wrap_new_OpenClose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OpenClose *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenClose";
  
  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 ;
  FIX::OpenClose *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OpenClose";
  
  if ((argc < 1) || (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), "in method '" "FIX::OpenClose" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OpenClose" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OpenClose'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OpenClose(FIX::OpenClose *arg1) {
    delete arg1;
}

swig_class cContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_ContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContractMultiplierUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplierUnit";
  
  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 ;
  FIX::ContractMultiplierUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContractMultiplierUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContractMultiplierUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContractMultiplierUnit(FIX::ContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class cSecondaryLowLimitPrice;

SWIGINTERN VALUE
_wrap_new_SecondaryLowLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryLowLimitPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryLowLimitPrice";
  
  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 ;
  FIX::SecondaryLowLimitPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryLowLimitPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecondaryLowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryLowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryLowLimitPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryLowLimitPrice(FIX::SecondaryLowLimitPrice *arg1) {
    delete arg1;
}

swig_class cExpQty;

SWIGINTERN VALUE
_wrap_new_ExpQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExpQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpQty";
  
  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 ;
  FIX::ExpQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExpQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExpQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExpQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExpQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExpQty(FIX::ExpQty *arg1) {
    delete arg1;
}

swig_class cNetworkRequestID;

SWIGINTERN VALUE
_wrap_new_NetworkRequestID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NetworkRequestID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestID";
  
  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 ;
  FIX::NetworkRequestID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkRequestID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NetworkRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NetworkRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetworkRequestID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkRequestID(FIX::NetworkRequestID *arg1) {
    delete arg1;
}

swig_class cTrdType;

SWIGINTERN VALUE
_wrap_new_TrdType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdType";
  
  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 ;
  FIX::TrdType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdType(FIX::TrdType *arg1) {
    delete arg1;
}

swig_class cNoUnderlyings;

SWIGINTERN VALUE
_wrap_new_NoUnderlyings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoUnderlyings *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyings";
  
  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 ;
  FIX::NoUnderlyings *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyings";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoUnderlyings'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyings(FIX::NoUnderlyings *arg1) {
    delete arg1;
}

swig_class cMDMkt;

SWIGINTERN VALUE
_wrap_new_MDMkt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDMkt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDMkt";
  
  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 ;
  FIX::MDMkt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDMkt";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDMkt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDMkt(FIX::MDMkt *arg1) {
    delete arg1;
}

swig_class cLastMkt;

SWIGINTERN VALUE
_wrap_new_LastMkt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastMkt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastMkt";
  
  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 ;
  FIX::LastMkt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastMkt";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastMkt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastMkt(FIX::LastMkt *arg1) {
    delete arg1;
}

swig_class cRestructuringType;

SWIGINTERN VALUE
_wrap_new_RestructuringType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RestructuringType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RestructuringType";
  
  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 ;
  FIX::RestructuringType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RestructuringType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RestructuringType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RestructuringType(FIX::RestructuringType *arg1) {
    delete arg1;
}

swig_class cNoStrikeRules;

SWIGINTERN VALUE
_wrap_new_NoStrikeRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoStrikeRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrikeRules";
  
  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 ;
  FIX::NoStrikeRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrikeRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoStrikeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoStrikeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoStrikeRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStrikeRules(FIX::NoStrikeRules *arg1) {
    delete arg1;
}

swig_class cListName;

SWIGINTERN VALUE
_wrap_new_ListName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListName";
  
  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 ;
  FIX::ListName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListName(FIX::ListName *arg1) {
    delete arg1;
}

swig_class cProgRptReqs;

SWIGINTERN VALUE
_wrap_new_ProgRptReqs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ProgRptReqs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProgRptReqs";
  
  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 ;
  FIX::ProgRptReqs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProgRptReqs";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ProgRptReqs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ProgRptReqs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ProgRptReqs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ProgRptReqs(FIX::ProgRptReqs *arg1) {
    delete arg1;
}

swig_class cTradingSessionID;

SWIGINTERN VALUE
_wrap_new_TradingSessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradingSessionID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionID";
  
  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 ;
  FIX::TradingSessionID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradingSessionID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingSessionID(FIX::TradingSessionID *arg1) {
    delete arg1;
}

swig_class cListOrderStatus;

SWIGINTERN VALUE
_wrap_new_ListOrderStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListOrderStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListOrderStatus";
  
  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 ;
  FIX::ListOrderStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListOrderStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListOrderStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListOrderStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListOrderStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListOrderStatus(FIX::ListOrderStatus *arg1) {
    delete arg1;
}

swig_class cRegistStatus;

SWIGINTERN VALUE
_wrap_new_RegistStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistStatus";
  
  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 ;
  FIX::RegistStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistStatus";
  
  if ((argc < 1) || (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), "in method '" "FIX::RegistStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistStatus(FIX::RegistStatus *arg1) {
    delete arg1;
}

swig_class cPosAmt;

SWIGINTERN VALUE
_wrap_new_PosAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosAmt";
  
  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 ;
  FIX::PosAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::PosAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosAmt(FIX::PosAmt *arg1) {
    delete arg1;
}

swig_class cUnderlyingPriceDeterminationMethod;

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceDeterminationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingPriceDeterminationMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceDeterminationMethod";
  
  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 ;
  FIX::UnderlyingPriceDeterminationMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceDeterminationMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingPriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingPriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingPriceDeterminationMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPriceDeterminationMethod(FIX::UnderlyingPriceDeterminationMethod *arg1) {
    delete arg1;
}

swig_class cNoUnderlyingStips;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingStips__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoUnderlyingStips *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingStips";
  
  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 ;
  FIX::NoUnderlyingStips *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingStips";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoUnderlyingStips" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoUnderlyingStips" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoUnderlyingStips'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingStips(FIX::NoUnderlyingStips *arg1) {
    delete arg1;
}

swig_class cTradSesPreCloseTime;

SWIGINTERN VALUE
_wrap_new_TradSesPreCloseTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesPreCloseTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  
  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 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  
  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), "in method '" "FIX::TradSesPreCloseTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesPreCloseTime";
  
  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), "in method '" "FIX::TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TradSesPreCloseTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesPreCloseTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesPreCloseTime(FIX::TradSesPreCloseTime *arg1) {
    delete arg1;
}

swig_class cMassCancelRequestType;

SWIGINTERN VALUE
_wrap_new_MassCancelRequestType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassCancelRequestType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRequestType";
  
  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 ;
  FIX::MassCancelRequestType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassCancelRequestType";
  
  if ((argc < 1) || (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), "in method '" "FIX::MassCancelRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassCancelRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassCancelRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassCancelRequestType(FIX::MassCancelRequestType *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecurityAltIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltIDSource";
  
  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 ;
  FIX::UnderlyingLegSecurityAltIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecurityAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityAltIDSource(FIX::UnderlyingLegSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class cSettlPartyID;

SWIGINTERN VALUE
_wrap_new_SettlPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyID";
  
  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 ;
  FIX::SettlPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartyID(FIX::SettlPartyID *arg1) {
    delete arg1;
}

swig_class cNoAffectedOrders;

SWIGINTERN VALUE
_wrap_new_NoAffectedOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoAffectedOrders *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAffectedOrders";
  
  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 ;
  FIX::NoAffectedOrders *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAffectedOrders";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoAffectedOrders'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAffectedOrders(FIX::NoAffectedOrders *arg1) {
    delete arg1;
}

swig_class cCashSettlAgentAcctNum;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentAcctNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashSettlAgentAcctNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctNum";
  
  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 ;
  FIX::CashSettlAgentAcctNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentAcctNum";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashSettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashSettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashSettlAgentAcctNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentAcctNum(FIX::CashSettlAgentAcctNum *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegMaturityMonthYear;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegMaturityMonthYear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegMaturityMonthYear *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityMonthYear";
  
  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 ;
  FIX::UnderlyingLegMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingLegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegMaturityMonthYear(FIX::UnderlyingLegMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityListRequestType;

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


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

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


SWIGINTERN VALUE _wrap_new_DerivativeSecurityListRequestType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DerivativeSecurityListRequestType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityListRequestType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityListRequestType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityListRequestType(FIX::DerivativeSecurityListRequestType *arg1) {
    delete arg1;
}

swig_class cNoLotTypeRules;

SWIGINTERN VALUE
_wrap_new_NoLotTypeRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoLotTypeRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLotTypeRules";
  
  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 ;
  FIX::NoLotTypeRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLotTypeRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoLotTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoLotTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoLotTypeRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLotTypeRules(FIX::NoLotTypeRules *arg1) {
    delete arg1;
}

swig_class cNoDates;

SWIGINTERN VALUE
_wrap_new_NoDates__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDates *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDates";
  
  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::INT *arg1 = 0 ;
  FIX::NoDates *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDates";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NoDates" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDates" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  result = (FIX::NoDates *)new FIX::NoDates((FIX::INT 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__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDates__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDates'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDates(FIX::NoDates *arg1) {
    delete arg1;
}

swig_class cCxlRejResponseTo;

SWIGINTERN VALUE
_wrap_new_CxlRejResponseTo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CxlRejResponseTo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlRejResponseTo";
  
  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 ;
  FIX::CxlRejResponseTo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlRejResponseTo";
  
  if ((argc < 1) || (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), "in method '" "FIX::CxlRejResponseTo" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CxlRejResponseTo" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CxlRejResponseTo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlRejResponseTo(FIX::CxlRejResponseTo *arg1) {
    delete arg1;
}

swig_class cEffectiveTime;

SWIGINTERN VALUE
_wrap_new_EffectiveTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EffectiveTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  
  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 ;
  FIX::EffectiveTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  
  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), "in method '" "FIX::EffectiveTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::EffectiveTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::EffectiveTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EffectiveTime";
  
  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), "in method '" "FIX::EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::EffectiveTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EffectiveTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EffectiveTime(FIX::EffectiveTime *arg1) {
    delete arg1;
}

swig_class cGrossTradeAmt;

SWIGINTERN VALUE
_wrap_new_GrossTradeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::GrossTradeAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GrossTradeAmt";
  
  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 ;
  FIX::GrossTradeAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GrossTradeAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::GrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::GrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_GrossTradeAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_GrossTradeAmt(FIX::GrossTradeAmt *arg1) {
    delete arg1;
}

swig_class cContextPartyID;

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


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

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


SWIGINTERN VALUE _wrap_new_ContextPartyID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContextPartyID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContextPartyID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContextPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContextPartyID(FIX::ContextPartyID *arg1) {
    delete arg1;
}

swig_class cSecurityListDesc;

SWIGINTERN VALUE
_wrap_new_SecurityListDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityListDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListDesc";
  
  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 ;
  FIX::SecurityListDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityListDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityListDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityListDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityListDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityListDesc(FIX::SecurityListDesc *arg1) {
    delete arg1;
}

swig_class cNotAffectedOrderID;

SWIGINTERN VALUE
_wrap_new_NotAffectedOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NotAffectedOrderID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotAffectedOrderID";
  
  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 ;
  FIX::NotAffectedOrderID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotAffectedOrderID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NotAffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NotAffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NotAffectedOrderID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NotAffectedOrderID(FIX::NotAffectedOrderID *arg1) {
    delete arg1;
}

swig_class cDerivativeStrikeValue;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeStrikeValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeValue";
  
  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 ;
  FIX::DerivativeStrikeValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeStrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeStrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeStrikeValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikeValue(FIX::DerivativeStrikeValue *arg1) {
    delete arg1;
}

swig_class cNoPosAmt;

SWIGINTERN VALUE
_wrap_new_NoPosAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoPosAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPosAmt";
  
  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 ;
  FIX::NoPosAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPosAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPosAmt" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPosAmt" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPosAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPosAmt(FIX::NoPosAmt *arg1) {
    delete arg1;
}

swig_class cLegCreditRating;

SWIGINTERN VALUE
_wrap_new_LegCreditRating__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCreditRating *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCreditRating";
  
  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 ;
  FIX::LegCreditRating *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCreditRating";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCreditRating'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCreditRating(FIX::LegCreditRating *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskInstrumentSettlType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskInstrumentSettlType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskInstrumentSettlType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskInstrumentSettlType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskInstrumentSettlType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskInstrumentSettlType(FIX::RelationshipRiskInstrumentSettlType *arg1) {
    delete arg1;
}

swig_class cBidForwardPoints2;

SWIGINTERN VALUE
_wrap_new_BidForwardPoints2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidForwardPoints2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints2";
  
  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 ;
  FIX::BidForwardPoints2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidForwardPoints2";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidForwardPoints2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidForwardPoints2(FIX::BidForwardPoints2 *arg1) {
    delete arg1;
}

swig_class cSettlDate;

SWIGINTERN VALUE
_wrap_new_SettlDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDate";
  
  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 ;
  FIX::SettlDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDate(FIX::SettlDate *arg1) {
    delete arg1;
}

swig_class cClientID;

SWIGINTERN VALUE
_wrap_new_ClientID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClientID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClientID";
  
  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 ;
  FIX::ClientID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClientID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClientID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClientID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClientID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClientID(FIX::ClientID *arg1) {
    delete arg1;
}

swig_class cQuoteCancelType;

SWIGINTERN VALUE
_wrap_new_QuoteCancelType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteCancelType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteCancelType";
  
  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 ;
  FIX::QuoteCancelType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteCancelType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteCancelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteCancelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteCancelType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteCancelType(FIX::QuoteCancelType *arg1) {
    delete arg1;
}

swig_class cStipulationType;

SWIGINTERN VALUE
_wrap_new_StipulationType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StipulationType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StipulationType";
  
  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 ;
  FIX::StipulationType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StipulationType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StipulationType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StipulationType(FIX::StipulationType *arg1) {
    delete arg1;
}

swig_class cOutMainCntryUIndex;

SWIGINTERN VALUE
_wrap_new_OutMainCntryUIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OutMainCntryUIndex *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OutMainCntryUIndex";
  
  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 ;
  FIX::OutMainCntryUIndex *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OutMainCntryUIndex";
  
  if ((argc < 1) || (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), "in method '" "FIX::OutMainCntryUIndex" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OutMainCntryUIndex" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OutMainCntryUIndex'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OutMainCntryUIndex(FIX::OutMainCntryUIndex *arg1) {
    delete arg1;
}

swig_class cLegSettlmntTyp;

SWIGINTERN VALUE
_wrap_new_LegSettlmntTyp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSettlmntTyp *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlmntTyp";
  
  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 ;
  FIX::LegSettlmntTyp *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlmntTyp";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegSettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSettlmntTyp'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlmntTyp(FIX::LegSettlmntTyp *arg1) {
    delete arg1;
}

swig_class cNoRelationshipRiskInstruments;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelationshipRiskInstruments__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskInstruments *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelationshipRiskInstruments";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelationshipRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelationshipRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelationshipRiskInstruments *)new FIX::NoRelationshipRiskInstruments((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelationshipRiskInstruments(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelationshipRiskInstruments__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_NoRelationshipRiskInstruments__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelationshipRiskInstruments'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelationshipRiskInstruments(FIX::NoRelationshipRiskInstruments *arg1) {
    delete arg1;
}

swig_class cDerivativeNTPositionLimit;

SWIGINTERN VALUE
_wrap_new_DerivativeNTPositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeNTPositionLimit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeNTPositionLimit";
  
  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 ;
  FIX::DerivativeNTPositionLimit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeNTPositionLimit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeNTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeNTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeNTPositionLimit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeNTPositionLimit(FIX::DerivativeNTPositionLimit *arg1) {
    delete arg1;
}

swig_class cPriceQuoteMethod;

SWIGINTERN VALUE
_wrap_new_PriceQuoteMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceQuoteMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceQuoteMethod";
  
  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 ;
  FIX::PriceQuoteMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceQuoteMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceQuoteMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceQuoteMethod(FIX::PriceQuoteMethod *arg1) {
    delete arg1;
}

swig_class cLowLimitPrice;

SWIGINTERN VALUE
_wrap_new_LowLimitPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LowLimitPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LowLimitPrice";
  
  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 ;
  FIX::LowLimitPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LowLimitPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::LowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LowLimitPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LowLimitPrice(FIX::LowLimitPrice *arg1) {
    delete arg1;
}

swig_class cLegUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_LegUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegUnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasure";
  
  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 ;
  FIX::LegUnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegUnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegUnitOfMeasure(FIX::LegUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cSessionRejectReason;

SWIGINTERN VALUE
_wrap_new_SessionRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionRejectReason";
  
  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 ;
  FIX::SessionRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SessionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SessionRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionRejectReason(FIX::SessionRejectReason *arg1) {
    delete arg1;
}

swig_class cPartyDetailsListReportID;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyDetailsListReportID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyDetailsListReportID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyDetailsListReportID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyDetailsListReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyDetailsListReportID(FIX::PartyDetailsListReportID *arg1) {
    delete arg1;
}

swig_class cDeliveryType;

SWIGINTERN VALUE
_wrap_new_DeliveryType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeliveryType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryType";
  
  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 ;
  FIX::DeliveryType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliveryType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeliveryType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliveryType(FIX::DeliveryType *arg1) {
    delete arg1;
}

swig_class cAllocPrice;

SWIGINTERN VALUE
_wrap_new_AllocPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocPrice";
  
  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 ;
  FIX::AllocPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocPrice(FIX::AllocPrice *arg1) {
    delete arg1;
}

swig_class cNoBidComponents;

SWIGINTERN VALUE
_wrap_new_NoBidComponents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoBidComponents *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoBidComponents";
  
  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 ;
  FIX::NoBidComponents *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoBidComponents";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoBidComponents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoBidComponents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoBidComponents'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoBidComponents(FIX::NoBidComponents *arg1) {
    delete arg1;
}

swig_class cQuoteQualifier;

SWIGINTERN VALUE
_wrap_new_QuoteQualifier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteQualifier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteQualifier";
  
  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 ;
  FIX::QuoteQualifier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteQualifier";
  
  if ((argc < 1) || (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), "in method '" "FIX::QuoteQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteQualifier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteQualifier(FIX::QuoteQualifier *arg1) {
    delete arg1;
}

swig_class cScope;

SWIGINTERN VALUE
_wrap_new_Scope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Scope *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Scope";
  
  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 ;
  FIX::Scope *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Scope";
  
  if ((argc < 1) || (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), "in method '" "FIX::Scope" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Scope" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Scope'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Scope(FIX::Scope *arg1) {
    delete arg1;
}

swig_class cNoSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityAltID";
  
  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 ;
  FIX::NoSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityAltID";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSecurityAltID(FIX::NoSecurityAltID *arg1) {
    delete arg1;
}

swig_class cRootPartySubID;

SWIGINTERN VALUE
_wrap_new_RootPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RootPartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubID";
  
  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 ;
  FIX::RootPartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RootPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RootPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RootPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartySubID(FIX::RootPartySubID *arg1) {
    delete arg1;
}

swig_class cDeliverToLocationID;

SWIGINTERN VALUE
_wrap_new_DeliverToLocationID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeliverToLocationID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToLocationID";
  
  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 ;
  FIX::DeliverToLocationID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeliverToLocationID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeliverToLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeliverToLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeliverToLocationID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeliverToLocationID(FIX::DeliverToLocationID *arg1) {
    delete arg1;
}

swig_class cDeleteReason;

SWIGINTERN VALUE
_wrap_new_DeleteReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeleteReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeleteReason";
  
  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 ;
  FIX::DeleteReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeleteReason";
  
  if ((argc < 1) || (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), "in method '" "FIX::DeleteReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeleteReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeleteReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeleteReason(FIX::DeleteReason *arg1) {
    delete arg1;
}

swig_class cBidSpotRate;

SWIGINTERN VALUE
_wrap_new_BidSpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidSpotRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSpotRate";
  
  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 ;
  FIX::BidSpotRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSpotRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidSpotRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidSpotRate(FIX::BidSpotRate *arg1) {
    delete arg1;
}

swig_class cNested4PartyID;

SWIGINTERN VALUE
_wrap_new_Nested4PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested4PartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyID";
  
  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 ;
  FIX::Nested4PartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested4PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested4PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested4PartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartyID(FIX::Nested4PartyID *arg1) {
    delete arg1;
}

swig_class cInViewOfCommon;

SWIGINTERN VALUE
_wrap_new_InViewOfCommon__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InViewOfCommon *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InViewOfCommon";
  
  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 ;
  FIX::InViewOfCommon *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InViewOfCommon";
  
  if ((argc < 1) || (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), "in method '" "FIX::InViewOfCommon" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InViewOfCommon" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InViewOfCommon'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InViewOfCommon(FIX::InViewOfCommon *arg1) {
    delete arg1;
}

swig_class cUnderlyingSettlPrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSettlPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPrice";
  
  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 ;
  FIX::UnderlyingSettlPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSettlPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlPrice(FIX::UnderlyingSettlPrice *arg1) {
    delete arg1;
}

swig_class cRegistRejReasonText;

SWIGINTERN VALUE
_wrap_new_RegistRejReasonText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistRejReasonText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonText";
  
  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 ;
  FIX::RegistRejReasonText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistRejReasonText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistRejReasonText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistRejReasonText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistRejReasonText(FIX::RegistRejReasonText *arg1) {
    delete arg1;
}

swig_class cNoSides;

SWIGINTERN VALUE
_wrap_new_NoSides__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSides *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSides";
  
  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 ;
  FIX::NoSides *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSides";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSides" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSides" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSides'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSides(FIX::NoSides *arg1) {
    delete arg1;
}

swig_class cLegAllocAccount;

SWIGINTERN VALUE
_wrap_new_LegAllocAccount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegAllocAccount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAccount";
  
  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 ;
  FIX::LegAllocAccount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAccount";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegAllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegAllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegAllocAccount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocAccount(FIX::LegAllocAccount *arg1) {
    delete arg1;
}

swig_class cNoRelationshipRiskWarningLevels;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelationshipRiskWarningLevels__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskWarningLevels *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelationshipRiskWarningLevels";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelationshipRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelationshipRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelationshipRiskWarningLevels *)new FIX::NoRelationshipRiskWarningLevels((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelationshipRiskWarningLevels(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelationshipRiskWarningLevels__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_NoRelationshipRiskWarningLevels__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelationshipRiskWarningLevels'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelationshipRiskWarningLevels(FIX::NoRelationshipRiskWarningLevels *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskProduct;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskProduct(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskProduct__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskProduct__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskProduct'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskProduct(FIX::RelationshipRiskProduct *arg1) {
    delete arg1;
}

swig_class cLegSecurityDesc;

SWIGINTERN VALUE
_wrap_new_LegSecurityDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecurityDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityDesc";
  
  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 ;
  FIX::LegSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityDesc(FIX::LegSecurityDesc *arg1) {
    delete arg1;
}

swig_class cClOrdLinkID;

SWIGINTERN VALUE
_wrap_new_ClOrdLinkID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClOrdLinkID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClOrdLinkID";
  
  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 ;
  FIX::ClOrdLinkID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClOrdLinkID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClOrdLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClOrdLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClOrdLinkID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClOrdLinkID(FIX::ClOrdLinkID *arg1) {
    delete arg1;
}

swig_class cOrigSendingTime;

SWIGINTERN VALUE
_wrap_new_OrigSendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigSendingTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  
  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 ;
  FIX::OrigSendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  
  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), "in method '" "FIX::OrigSendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::OrigSendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::OrigSendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSendingTime";
  
  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), "in method '" "FIX::OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::OrigSendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigSendingTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigSendingTime(FIX::OrigSendingTime *arg1) {
    delete arg1;
}

swig_class cEncodedLegIssuerLen;

SWIGINTERN VALUE
_wrap_new_EncodedLegIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedLegIssuerLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuerLen";
  
  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 ;
  FIX::EncodedLegIssuerLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedLegIssuerLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedLegIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedLegIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedLegIssuerLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedLegIssuerLen(FIX::EncodedLegIssuerLen *arg1) {
    delete arg1;
}

swig_class cOrderID;

SWIGINTERN VALUE
_wrap_new_OrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderID";
  
  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 ;
  FIX::OrderID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderID(FIX::OrderID *arg1) {
    delete arg1;
}

swig_class cSecurityType;

SWIGINTERN VALUE
_wrap_new_SecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityType";
  
  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 ;
  FIX::SecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityType(FIX::SecurityType *arg1) {
    delete arg1;
}

swig_class cRoundingDirection;

SWIGINTERN VALUE
_wrap_new_RoundingDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RoundingDirection *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundingDirection";
  
  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 ;
  FIX::RoundingDirection *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundingDirection";
  
  if ((argc < 1) || (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), "in method '" "FIX::RoundingDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RoundingDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RoundingDirection'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RoundingDirection(FIX::RoundingDirection *arg1) {
    delete arg1;
}

swig_class cFillExecID;

SWIGINTERN VALUE
_wrap_new_FillExecID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FillExecID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillExecID";
  
  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 ;
  FIX::FillExecID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillExecID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::FillExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FillExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FillExecID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FillExecID(FIX::FillExecID *arg1) {
    delete arg1;
}

swig_class cNoEvents;

SWIGINTERN VALUE
_wrap_new_NoEvents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoEvents *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoEvents";
  
  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 ;
  FIX::NoEvents *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoEvents";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoEvents'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoEvents(FIX::NoEvents *arg1) {
    delete arg1;
}

swig_class cRoundLot;

SWIGINTERN VALUE
_wrap_new_RoundLot__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RoundLot *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundLot";
  
  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 ;
  FIX::RoundLot *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundLot";
  
  if ((argc < 1) || (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), "in method '" "FIX::RoundLot" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RoundLot" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RoundLot'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RoundLot(FIX::RoundLot *arg1) {
    delete arg1;
}

swig_class cMDEntrySize;

SWIGINTERN VALUE
_wrap_new_MDEntrySize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntrySize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySize";
  
  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 ;
  FIX::MDEntrySize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntrySize";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDEntrySize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntrySize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntrySize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntrySize(FIX::MDEntrySize *arg1) {
    delete arg1;
}

swig_class cEncodedIssuerLen;

SWIGINTERN VALUE
_wrap_new_EncodedIssuerLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedIssuerLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuerLen";
  
  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 ;
  FIX::EncodedIssuerLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedIssuerLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedIssuerLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedIssuerLen(FIX::EncodedIssuerLen *arg1) {
    delete arg1;
}

swig_class cDerivativePriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativePriceUnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasureQty";
  
  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 ;
  FIX::DerivativePriceUnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePriceUnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativePriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativePriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativePriceUnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePriceUnitOfMeasureQty(FIX::DerivativePriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cTimeUnit;

SWIGINTERN VALUE
_wrap_new_TimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TimeUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeUnit";
  
  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 ;
  FIX::TimeUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TimeUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeUnit(FIX::TimeUnit *arg1) {
    delete arg1;
}

swig_class cTotNoOrders;

SWIGINTERN VALUE
_wrap_new_TotNoOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoOrders *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoOrders";
  
  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 ;
  FIX::TotNoOrders *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoOrders";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoOrders'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoOrders(FIX::TotNoOrders *arg1) {
    delete arg1;
}

swig_class cPartyAltID;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyAltID(FIX::PartyAltID *arg1) {
    delete arg1;
}

swig_class cLegSwapType;

SWIGINTERN VALUE
_wrap_new_LegSwapType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSwapType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSwapType";
  
  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 ;
  FIX::LegSwapType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSwapType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSwapType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSwapType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSwapType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSwapType(FIX::LegSwapType *arg1) {
    delete arg1;
}

swig_class cIOITransType;

SWIGINTERN VALUE
_wrap_new_IOITransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOITransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOITransType";
  
  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 ;
  FIX::IOITransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOITransType";
  
  if ((argc < 1) || (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), "in method '" "FIX::IOITransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOITransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOITransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOITransType(FIX::IOITransType *arg1) {
    delete arg1;
}

swig_class cRawDataLength;

SWIGINTERN VALUE
_wrap_new_RawDataLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RawDataLength *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RawDataLength";
  
  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 ;
  FIX::RawDataLength *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RawDataLength";
  
  if ((argc < 1) || (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), "in method '" "FIX::RawDataLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RawDataLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RawDataLength'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RawDataLength(FIX::RawDataLength *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecurityType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecurityType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityType";
  
  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 ;
  FIX::UnderlyingSecurityType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityType(FIX::UnderlyingSecurityType *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltID";
  
  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 ;
  FIX::UnderlyingLegSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityAltID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityAltID(FIX::UnderlyingLegSecurityAltID *arg1) {
    delete arg1;
}

swig_class cSecurityReportID;

SWIGINTERN VALUE
_wrap_new_SecurityReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityReportID";
  
  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 ;
  FIX::SecurityReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityReportID(FIX::SecurityReportID *arg1) {
    delete arg1;
}

swig_class cTotNumReports;

SWIGINTERN VALUE
_wrap_new_TotNumReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNumReports *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumReports";
  
  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 ;
  FIX::TotNumReports *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumReports";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNumReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNumReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNumReports'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNumReports(FIX::TotNumReports *arg1) {
    delete arg1;
}

swig_class cTotalNumPosReports;

SWIGINTERN VALUE
_wrap_new_TotalNumPosReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalNumPosReports *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumPosReports";
  
  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 ;
  FIX::TotalNumPosReports *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNumPosReports";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotalNumPosReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalNumPosReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalNumPosReports'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNumPosReports(FIX::TotalNumPosReports *arg1) {
    delete arg1;
}

swig_class cSecurityReqID;

SWIGINTERN VALUE
_wrap_new_SecurityReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityReqID";
  
  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 ;
  FIX::SecurityReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityReqID(FIX::SecurityReqID *arg1) {
    delete arg1;
}

swig_class cPosReqResult;

SWIGINTERN VALUE
_wrap_new_PosReqResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosReqResult *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqResult";
  
  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 ;
  FIX::PosReqResult *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqResult";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosReqResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosReqResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosReqResult'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqResult(FIX::PosReqResult *arg1) {
    delete arg1;
}

swig_class cLegOfferForwardPoints;

SWIGINTERN VALUE
_wrap_new_LegOfferForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegOfferForwardPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOfferForwardPoints";
  
  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 ;
  FIX::LegOfferForwardPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOfferForwardPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegOfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegOfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegOfferForwardPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOfferForwardPoints(FIX::LegOfferForwardPoints *arg1) {
    delete arg1;
}

swig_class cAllowableOneSidednessCurr;

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllowableOneSidednessCurr *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessCurr";
  
  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 ;
  FIX::AllowableOneSidednessCurr *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessCurr";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllowableOneSidednessCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllowableOneSidednessCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllowableOneSidednessCurr'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllowableOneSidednessCurr(FIX::AllowableOneSidednessCurr *arg1) {
    delete arg1;
}

swig_class cAffectedOrderID;

SWIGINTERN VALUE
_wrap_new_AffectedOrderID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AffectedOrderID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffectedOrderID";
  
  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 ;
  FIX::AffectedOrderID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AffectedOrderID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AffectedOrderID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AffectedOrderID(FIX::AffectedOrderID *arg1) {
    delete arg1;
}

swig_class cUnderlyingCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_UnderlyingCountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCountryOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCountryOfIssue";
  
  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 ;
  FIX::UnderlyingCountryOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCountryOfIssue";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCountryOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCountryOfIssue(FIX::UnderlyingCountryOfIssue *arg1) {
    delete arg1;
}

swig_class cUnderlyingRepurchaseRate;

SWIGINTERN VALUE
_wrap_new_UnderlyingRepurchaseRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingRepurchaseRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseRate";
  
  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 ;
  FIX::UnderlyingRepurchaseRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRepurchaseRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingRepurchaseRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRepurchaseRate(FIX::UnderlyingRepurchaseRate *arg1) {
    delete arg1;
}

swig_class cLastMsgSeqNumProcessed;

SWIGINTERN VALUE
_wrap_new_LastMsgSeqNumProcessed__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastMsgSeqNumProcessed *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastMsgSeqNumProcessed";
  
  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 ;
  FIX::LastMsgSeqNumProcessed *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastMsgSeqNumProcessed";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastMsgSeqNumProcessed" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastMsgSeqNumProcessed" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastMsgSeqNumProcessed'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastMsgSeqNumProcessed(FIX::LastMsgSeqNumProcessed *arg1) {
    delete arg1;
}

swig_class cUnderlyingCFICode;

SWIGINTERN VALUE
_wrap_new_UnderlyingCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCFICode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCFICode";
  
  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 ;
  FIX::UnderlyingCFICode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCFICode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCFICode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCFICode(FIX::UnderlyingCFICode *arg1) {
    delete arg1;
}

swig_class cDerivativeOptAttribute;

SWIGINTERN VALUE
_wrap_new_DerivativeOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeOptAttribute *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptAttribute";
  
  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 ;
  FIX::DerivativeOptAttribute *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptAttribute";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeOptAttribute'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeOptAttribute(FIX::DerivativeOptAttribute *arg1) {
    delete arg1;
}

swig_class cPegSecurityID;

SWIGINTERN VALUE
_wrap_new_PegSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegSecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityID";
  
  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 ;
  FIX::PegSecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSecurityID(FIX::PegSecurityID *arg1) {
    delete arg1;
}

swig_class cHostCrossID;

SWIGINTERN VALUE
_wrap_new_HostCrossID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HostCrossID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HostCrossID";
  
  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 ;
  FIX::HostCrossID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HostCrossID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::HostCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HostCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HostCrossID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HostCrossID(FIX::HostCrossID *arg1) {
    delete arg1;
}

swig_class cExecInstValue;

SWIGINTERN VALUE
_wrap_new_ExecInstValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecInstValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecInstValue";
  
  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 ;
  FIX::ExecInstValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecInstValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecInstValue" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecInstValue" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecInstValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecInstValue(FIX::ExecInstValue *arg1) {
    delete arg1;
}

swig_class cDerivativeOptPayAmount;

SWIGINTERN VALUE
_wrap_new_DerivativeOptPayAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeOptPayAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptPayAmount";
  
  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 ;
  FIX::DerivativeOptPayAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeOptPayAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeOptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeOptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeOptPayAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeOptPayAmount(FIX::DerivativeOptPayAmount *arg1) {
    delete arg1;
}

swig_class cUnderlyingCouponRate;

SWIGINTERN VALUE
_wrap_new_UnderlyingCouponRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCouponRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponRate";
  
  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 ;
  FIX::UnderlyingCouponRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCouponRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCouponRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCouponRate(FIX::UnderlyingCouponRate *arg1) {
    delete arg1;
}

swig_class cSettlInstMode;

SWIGINTERN VALUE
_wrap_new_SettlInstMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstMode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMode";
  
  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 ;
  FIX::SettlInstMode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMode";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlInstMode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstMode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstMode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstMode(FIX::SettlInstMode *arg1) {
    delete arg1;
}

swig_class cSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_SecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityAltIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltIDSource";
  
  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 ;
  FIX::SecurityAltIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityAltIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityAltIDSource(FIX::SecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class cPreviouslyReported;

SWIGINTERN VALUE
_wrap_new_PreviouslyReported__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PreviouslyReported *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreviouslyReported";
  
  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 ;
  FIX::PreviouslyReported *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreviouslyReported";
  
  if ((argc < 1) || (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), "in method '" "FIX::PreviouslyReported" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PreviouslyReported" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PreviouslyReported'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PreviouslyReported(FIX::PreviouslyReported *arg1) {
    delete arg1;
}

swig_class cContextPartyIDSource;

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


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

SWIGINTERN VALUE
_wrap_new_ContextPartyIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  FIX::ContextPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContextPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContextPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::ContextPartyIDSource *)new FIX::ContextPartyIDSource((FIX::CHAR const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ContextPartyIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContextPartyIDSource__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_ContextPartyIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContextPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContextPartyIDSource(FIX::ContextPartyIDSource *arg1) {
    delete arg1;
}

swig_class cRptSys;

SWIGINTERN VALUE
_wrap_new_RptSys__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RptSys *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RptSys";
  
  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 ;
  FIX::RptSys *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RptSys";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RptSys" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RptSys" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RptSys'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RptSys(FIX::RptSys *arg1) {
    delete arg1;
}

swig_class cNoNested2PartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoNested2PartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNested2PartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartySubIDs";
  
  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 ;
  FIX::NoNested2PartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested2PartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNested2PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNested2PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNested2PartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested2PartySubIDs(FIX::NoNested2PartySubIDs *arg1) {
    delete arg1;
}

swig_class cRefAllocID;

SWIGINTERN VALUE
_wrap_new_RefAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefAllocID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefAllocID";
  
  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 ;
  FIX::RefAllocID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefAllocID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefAllocID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefAllocID(FIX::RefAllocID *arg1) {
    delete arg1;
}

swig_class cDefOfferSize;

SWIGINTERN VALUE
_wrap_new_DefOfferSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DefOfferSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefOfferSize";
  
  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 ;
  FIX::DefOfferSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefOfferSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::DefOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DefOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DefOfferSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DefOfferSize(FIX::DefOfferSize *arg1) {
    delete arg1;
}

swig_class cProductComplex;

SWIGINTERN VALUE
_wrap_new_ProductComplex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ProductComplex *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProductComplex";
  
  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 ;
  FIX::ProductComplex *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProductComplex";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ProductComplex'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ProductComplex(FIX::ProductComplex *arg1) {
    delete arg1;
}

swig_class cCustOrderHandlingInst;

SWIGINTERN VALUE
_wrap_new_CustOrderHandlingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CustOrderHandlingInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustOrderHandlingInst";
  
  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 ;
  FIX::CustOrderHandlingInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustOrderHandlingInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::CustOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CustOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CustOrderHandlingInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CustOrderHandlingInst(FIX::CustOrderHandlingInst *arg1) {
    delete arg1;
}

swig_class cMDPriceLevel;

SWIGINTERN VALUE
_wrap_new_MDPriceLevel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDPriceLevel *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDPriceLevel";
  
  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 ;
  FIX::MDPriceLevel *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDPriceLevel";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDPriceLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDPriceLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDPriceLevel'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDPriceLevel(FIX::MDPriceLevel *arg1) {
    delete arg1;
}

swig_class cLegOptionRatio;

SWIGINTERN VALUE
_wrap_new_LegOptionRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegOptionRatio *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOptionRatio";
  
  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 ;
  FIX::LegOptionRatio *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOptionRatio";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegOptionRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegOptionRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegOptionRatio'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOptionRatio(FIX::LegOptionRatio *arg1) {
    delete arg1;
}

swig_class cSecurityStatus;

SWIGINTERN VALUE
_wrap_new_SecurityStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatus";
  
  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 ;
  FIX::SecurityStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityStatus(FIX::SecurityStatus *arg1) {
    delete arg1;
}

swig_class cLegRefID;

SWIGINTERN VALUE
_wrap_new_LegRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRefID";
  
  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 ;
  FIX::LegRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRefID(FIX::LegRefID *arg1) {
    delete arg1;
}

swig_class cDividendYield;

SWIGINTERN VALUE
_wrap_new_DividendYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DividendYield *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DividendYield";
  
  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 ;
  FIX::DividendYield *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DividendYield";
  
  if ((argc < 1) || (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), "in method '" "FIX::DividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DividendYield'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DividendYield(FIX::DividendYield *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrumentPartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubIDType";
  
  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 ;
  FIX::DerivativeInstrumentPartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrumentPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartySubIDType(FIX::DerivativeInstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class cEndStrikePxRange;

SWIGINTERN VALUE
_wrap_new_EndStrikePxRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EndStrikePxRange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndStrikePxRange";
  
  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 ;
  FIX::EndStrikePxRange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndStrikePxRange";
  
  if ((argc < 1) || (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), "in method '" "FIX::EndStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EndStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EndStrikePxRange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EndStrikePxRange(FIX::EndStrikePxRange *arg1) {
    delete arg1;
}

swig_class cDisplayQty;

SWIGINTERN VALUE
_wrap_new_DisplayQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DisplayQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayQty";
  
  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 ;
  FIX::DisplayQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::DisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DisplayQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayQty(FIX::DisplayQty *arg1) {
    delete arg1;
}

swig_class cLegSecuritySubType;

SWIGINTERN VALUE
_wrap_new_LegSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecuritySubType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecuritySubType";
  
  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 ;
  FIX::LegSecuritySubType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecuritySubType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecuritySubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecuritySubType(FIX::LegSecuritySubType *arg1) {
    delete arg1;
}

swig_class cProcessCode;

SWIGINTERN VALUE
_wrap_new_ProcessCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ProcessCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProcessCode";
  
  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 ;
  FIX::ProcessCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ProcessCode";
  
  if ((argc < 1) || (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), "in method '" "FIX::ProcessCode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ProcessCode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ProcessCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ProcessCode(FIX::ProcessCode *arg1) {
    delete arg1;
}

swig_class cExecInst;

SWIGINTERN VALUE
_wrap_new_ExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecInst";
  
  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 ;
  FIX::ExecInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecInst(FIX::ExecInst *arg1) {
    delete arg1;
}

swig_class cTradSesEndTime;

SWIGINTERN VALUE
_wrap_new_TradSesEndTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesEndTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  
  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 ;
  FIX::TradSesEndTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  
  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), "in method '" "FIX::TradSesEndTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TradSesEndTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TradSesEndTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEndTime";
  
  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), "in method '" "FIX::TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TradSesEndTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesEndTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesEndTime(FIX::TradSesEndTime *arg1) {
    delete arg1;
}

swig_class cOrigTime;

SWIGINTERN VALUE
_wrap_new_OrigTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  
  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 ;
  FIX::OrigTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  
  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), "in method '" "FIX::OrigTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::OrigTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::OrigTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTime";
  
  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), "in method '" "FIX::OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::OrigTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTime(FIX::OrigTime *arg1) {
    delete arg1;
}

swig_class cExecValuationPoint;

SWIGINTERN VALUE
_wrap_new_ExecValuationPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecValuationPoint *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  
  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 ;
  FIX::ExecValuationPoint *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  
  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), "in method '" "FIX::ExecValuationPoint" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::ExecValuationPoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::ExecValuationPoint *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecValuationPoint";
  
  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), "in method '" "FIX::ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ExecValuationPoint" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecValuationPoint'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecValuationPoint(FIX::ExecValuationPoint *arg1) {
    delete arg1;
}

swig_class cExecType;

SWIGINTERN VALUE
_wrap_new_ExecType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecType";
  
  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 ;
  FIX::ExecType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecType";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecType(FIX::ExecType *arg1) {
    delete arg1;
}

swig_class cNoRelatedContextPartySubIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelatedContextPartySubIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedContextPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedContextPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelatedContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelatedContextPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelatedContextPartySubIDs *)new FIX::NoRelatedContextPartySubIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelatedContextPartySubIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelatedContextPartySubIDs__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_NoRelatedContextPartySubIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelatedContextPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedContextPartySubIDs(FIX::NoRelatedContextPartySubIDs *arg1) {
    delete arg1;
}

swig_class cNested4PartyRole;

SWIGINTERN VALUE
_wrap_new_Nested4PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested4PartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyRole";
  
  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 ;
  FIX::Nested4PartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested4PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested4PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested4PartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartyRole(FIX::Nested4PartyRole *arg1) {
    delete arg1;
}

swig_class cMultilegModel;

SWIGINTERN VALUE
_wrap_new_MultilegModel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MultilegModel *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultilegModel";
  
  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 ;
  FIX::MultilegModel *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MultilegModel";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MultilegModel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MultilegModel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MultilegModel'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MultilegModel(FIX::MultilegModel *arg1) {
    delete arg1;
}

swig_class cSecurityGroup;

SWIGINTERN VALUE
_wrap_new_SecurityGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityGroup *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityGroup";
  
  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 ;
  FIX::SecurityGroup *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityGroup";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityGroup'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityGroup(FIX::SecurityGroup *arg1) {
    delete arg1;
}

swig_class cEventType;

SWIGINTERN VALUE
_wrap_new_EventType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EventType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventType";
  
  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 ;
  FIX::EventType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::EventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EventType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EventType(FIX::EventType *arg1) {
    delete arg1;
}

swig_class cTradeAllocIndicator;

SWIGINTERN VALUE
_wrap_new_TradeAllocIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeAllocIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeAllocIndicator";
  
  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 ;
  FIX::TradeAllocIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeAllocIndicator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeAllocIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeAllocIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeAllocIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeAllocIndicator(FIX::TradeAllocIndicator *arg1) {
    delete arg1;
}

swig_class cYieldCalcDate;

SWIGINTERN VALUE
_wrap_new_YieldCalcDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::YieldCalcDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldCalcDate";
  
  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 ;
  FIX::YieldCalcDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldCalcDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::YieldCalcDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::YieldCalcDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_YieldCalcDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldCalcDate(FIX::YieldCalcDate *arg1) {
    delete arg1;
}

swig_class cValueOfFutures;

SWIGINTERN VALUE
_wrap_new_ValueOfFutures__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ValueOfFutures *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValueOfFutures";
  
  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 ;
  FIX::ValueOfFutures *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValueOfFutures";
  
  if ((argc < 1) || (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), "in method '" "FIX::ValueOfFutures" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ValueOfFutures" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ValueOfFutures'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ValueOfFutures(FIX::ValueOfFutures *arg1) {
    delete arg1;
}

swig_class cLegSide;

SWIGINTERN VALUE
_wrap_new_LegSide__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSide *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSide";
  
  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 ;
  FIX::LegSide *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSide";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSide'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSide(FIX::LegSide *arg1) {
    delete arg1;
}

swig_class cUserStatus;

SWIGINTERN VALUE
_wrap_new_UserStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UserStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserStatus";
  
  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 ;
  FIX::UserStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UserStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UserStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UserStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UserStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UserStatus(FIX::UserStatus *arg1) {
    delete arg1;
}

swig_class cSideValue1;

SWIGINTERN VALUE
_wrap_new_SideValue1__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideValue1 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValue1";
  
  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 ;
  FIX::SideValue1 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValue1";
  
  if ((argc < 1) || (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), "in method '" "FIX::SideValue1" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideValue1" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideValue1'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideValue1(FIX::SideValue1 *arg1) {
    delete arg1;
}

swig_class cCxlQty;

SWIGINTERN VALUE
_wrap_new_CxlQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CxlQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlQty";
  
  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 ;
  FIX::CxlQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::CxlQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CxlQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CxlQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlQty(FIX::CxlQty *arg1) {
    delete arg1;
}

swig_class cSecurityResponseID;

SWIGINTERN VALUE
_wrap_new_SecurityResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityResponseID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseID";
  
  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 ;
  FIX::SecurityResponseID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityResponseID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityResponseID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityResponseID(FIX::SecurityResponseID *arg1) {
    delete arg1;
}

swig_class cInstrRegistry;

SWIGINTERN VALUE
_wrap_new_InstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrRegistry *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrRegistry";
  
  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 ;
  FIX::InstrRegistry *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrRegistry";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrRegistry'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrRegistry(FIX::InstrRegistry *arg1) {
    delete arg1;
}

swig_class cStreamAsgnRptID;

SWIGINTERN VALUE
_wrap_new_StreamAsgnRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StreamAsgnRptID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRptID";
  
  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 ;
  FIX::StreamAsgnRptID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnRptID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StreamAsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StreamAsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StreamAsgnRptID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnRptID(FIX::StreamAsgnRptID *arg1) {
    delete arg1;
}

swig_class cOrderDelayUnit;

SWIGINTERN VALUE
_wrap_new_OrderDelayUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderDelayUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderDelayUnit";
  
  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 ;
  FIX::OrderDelayUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderDelayUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrderDelayUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderDelayUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderDelayUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderDelayUnit(FIX::OrderDelayUnit *arg1) {
    delete arg1;
}

swig_class cLegCurrencyRatio;

SWIGINTERN VALUE
_wrap_new_LegCurrencyRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCurrencyRatio *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCurrencyRatio";
  
  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 ;
  FIX::LegCurrencyRatio *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCurrencyRatio";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegCurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCurrencyRatio'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCurrencyRatio(FIX::LegCurrencyRatio *arg1) {
    delete arg1;
}

swig_class cEndTickPriceRange;

SWIGINTERN VALUE
_wrap_new_EndTickPriceRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EndTickPriceRange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndTickPriceRange";
  
  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 ;
  FIX::EndTickPriceRange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndTickPriceRange";
  
  if ((argc < 1) || (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), "in method '" "FIX::EndTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EndTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EndTickPriceRange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EndTickPriceRange(FIX::EndTickPriceRange *arg1) {
    delete arg1;
}

swig_class cCollReqID;

SWIGINTERN VALUE
_wrap_new_CollReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollReqID";
  
  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 ;
  FIX::CollReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollReqID(FIX::CollReqID *arg1) {
    delete arg1;
}

swig_class cLegPool;

SWIGINTERN VALUE
_wrap_new_LegPool__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegPool *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPool";
  
  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 ;
  FIX::LegPool *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPool";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegPool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegPool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegPool'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPool(FIX::LegPool *arg1) {
    delete arg1;
}

swig_class cShortQty;

SWIGINTERN VALUE
_wrap_new_ShortQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ShortQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ShortQty";
  
  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 ;
  FIX::ShortQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ShortQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::ShortQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ShortQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ShortQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ShortQty(FIX::ShortQty *arg1) {
    delete arg1;
}

swig_class cSideValue2;

SWIGINTERN VALUE
_wrap_new_SideValue2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideValue2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValue2";
  
  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 ;
  FIX::SideValue2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValue2";
  
  if ((argc < 1) || (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), "in method '" "FIX::SideValue2" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideValue2" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideValue2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideValue2(FIX::SideValue2 *arg1) {
    delete arg1;
}

swig_class cTradedFlatSwitch;

SWIGINTERN VALUE
_wrap_new_TradedFlatSwitch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradedFlatSwitch *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradedFlatSwitch";
  
  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 ;
  FIX::TradedFlatSwitch *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradedFlatSwitch";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradedFlatSwitch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradedFlatSwitch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradedFlatSwitch'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradedFlatSwitch(FIX::TradedFlatSwitch *arg1) {
    delete arg1;
}

swig_class cMassStatusReqID;

SWIGINTERN VALUE
_wrap_new_MassStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MassStatusReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqID";
  
  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 ;
  FIX::MassStatusReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MassStatusReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MassStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MassStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MassStatusReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MassStatusReqID(FIX::MassStatusReqID *arg1) {
    delete arg1;
}

swig_class cComplexEventEndDate;

SWIGINTERN VALUE
_wrap_new_ComplexEventEndDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventEndDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  
  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 ;
  FIX::ComplexEventEndDate *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  
  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), "in method '" "FIX::ComplexEventEndDate" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::ComplexEventEndDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::ComplexEventEndDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventEndDate";
  
  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), "in method '" "FIX::ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ComplexEventEndDate" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventEndDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventEndDate(FIX::ComplexEventEndDate *arg1) {
    delete arg1;
}

swig_class cMarketID;

SWIGINTERN VALUE
_wrap_new_MarketID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarketID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketID";
  
  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 ;
  FIX::MarketID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketID";
  
  if ((argc < 1) || (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), "in method '" "FIX::MarketID" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarketID" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarketID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketID(FIX::MarketID *arg1) {
    delete arg1;
}

swig_class cOrigTradeDate;

SWIGINTERN VALUE
_wrap_new_OrigTradeDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigTradeDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeDate";
  
  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 ;
  FIX::OrigTradeDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrigTradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigTradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigTradeDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTradeDate(FIX::OrigTradeDate *arg1) {
    delete arg1;
}

swig_class cPreTradeAnonymity;

SWIGINTERN VALUE
_wrap_new_PreTradeAnonymity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PreTradeAnonymity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreTradeAnonymity";
  
  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 ;
  FIX::PreTradeAnonymity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PreTradeAnonymity";
  
  if ((argc < 1) || (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), "in method '" "FIX::PreTradeAnonymity" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PreTradeAnonymity" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PreTradeAnonymity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PreTradeAnonymity(FIX::PreTradeAnonymity *arg1) {
    delete arg1;
}

swig_class cTrdRptStatus;

SWIGINTERN VALUE
_wrap_new_TrdRptStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdRptStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRptStatus";
  
  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 ;
  FIX::TrdRptStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRptStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TrdRptStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdRptStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdRptStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRptStatus(FIX::TrdRptStatus *arg1) {
    delete arg1;
}

swig_class cDistribPercentage;

SWIGINTERN VALUE
_wrap_new_DistribPercentage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DistribPercentage *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DistribPercentage";
  
  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 ;
  FIX::DistribPercentage *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DistribPercentage";
  
  if ((argc < 1) || (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), "in method '" "FIX::DistribPercentage" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DistribPercentage" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DistribPercentage'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DistribPercentage(FIX::DistribPercentage *arg1) {
    delete arg1;
}

swig_class cQuoteStatus;

SWIGINTERN VALUE
_wrap_new_QuoteStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatus";
  
  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 ;
  FIX::QuoteStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteStatus(FIX::QuoteStatus *arg1) {
    delete arg1;
}

swig_class cClearingAccount;

SWIGINTERN VALUE
_wrap_new_ClearingAccount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClearingAccount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingAccount";
  
  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 ;
  FIX::ClearingAccount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClearingAccount";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClearingAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClearingAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClearingAccount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClearingAccount(FIX::ClearingAccount *arg1) {
    delete arg1;
}

swig_class cTrdMatchID;

SWIGINTERN VALUE
_wrap_new_TrdMatchID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdMatchID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdMatchID";
  
  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 ;
  FIX::TrdMatchID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdMatchID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TrdMatchID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdMatchID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdMatchID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdMatchID(FIX::TrdMatchID *arg1) {
    delete arg1;
}

swig_class cOrderInputDevice;

SWIGINTERN VALUE
_wrap_new_OrderInputDevice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderInputDevice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderInputDevice";
  
  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 ;
  FIX::OrderInputDevice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderInputDevice";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrderInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderInputDevice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderInputDevice(FIX::OrderInputDevice *arg1) {
    delete arg1;
}

swig_class cSolicitedFlag;

SWIGINTERN VALUE
_wrap_new_SolicitedFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SolicitedFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SolicitedFlag";
  
  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 ;
  FIX::SolicitedFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SolicitedFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::SolicitedFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SolicitedFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SolicitedFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SolicitedFlag(FIX::SolicitedFlag *arg1) {
    delete arg1;
}

swig_class cTransactTime;

SWIGINTERN VALUE
_wrap_new_TransactTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TransactTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  
  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 ;
  FIX::TransactTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  
  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), "in method '" "FIX::TransactTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TransactTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TransactTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransactTime";
  
  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), "in method '" "FIX::TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TransactTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TransactTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TransactTime(FIX::TransactTime *arg1) {
    delete arg1;
}

swig_class cRiskLimitType;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskLimitType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskLimitType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskLimitType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskLimitType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskLimitType(FIX::RiskLimitType *arg1) {
    delete arg1;
}

swig_class cUnderlyingFlowScheduleType;

SWIGINTERN VALUE
_wrap_new_UnderlyingFlowScheduleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingFlowScheduleType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFlowScheduleType";
  
  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 ;
  FIX::UnderlyingFlowScheduleType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFlowScheduleType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingFlowScheduleType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFlowScheduleType(FIX::UnderlyingFlowScheduleType *arg1) {
    delete arg1;
}

swig_class cUnderlyingStipValue;

SWIGINTERN VALUE
_wrap_new_UnderlyingStipValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingStipValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipValue";
  
  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 ;
  FIX::UnderlyingStipValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingStipValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingStipValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingStipValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStipValue(FIX::UnderlyingStipValue *arg1) {
    delete arg1;
}

swig_class cNextExpectedMsgSeqNum;

SWIGINTERN VALUE
_wrap_new_NextExpectedMsgSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NextExpectedMsgSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NextExpectedMsgSeqNum";
  
  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 ;
  FIX::NextExpectedMsgSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NextExpectedMsgSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::NextExpectedMsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NextExpectedMsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NextExpectedMsgSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NextExpectedMsgSeqNum(FIX::NextExpectedMsgSeqNum *arg1) {
    delete arg1;
}

swig_class cBenchmarkCurveCurrency;

SWIGINTERN VALUE
_wrap_new_BenchmarkCurveCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BenchmarkCurveCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveCurrency";
  
  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 ;
  FIX::BenchmarkCurveCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::BenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BenchmarkCurveCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkCurveCurrency(FIX::BenchmarkCurveCurrency *arg1) {
    delete arg1;
}

swig_class cCFICode;

SWIGINTERN VALUE
_wrap_new_CFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CFICode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CFICode";
  
  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 ;
  FIX::CFICode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CFICode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CFICode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CFICode(FIX::CFICode *arg1) {
    delete arg1;
}

swig_class cFactor;

SWIGINTERN VALUE
_wrap_new_Factor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Factor *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Factor";
  
  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 ;
  FIX::Factor *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Factor";
  
  if ((argc < 1) || (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), "in method '" "FIX::Factor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Factor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Factor'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Factor(FIX::Factor *arg1) {
    delete arg1;
}

swig_class cLastShares;

SWIGINTERN VALUE
_wrap_new_LastShares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastShares *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastShares";
  
  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 ;
  FIX::LastShares *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastShares";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastShares'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastShares(FIX::LastShares *arg1) {
    delete arg1;
}

swig_class cRequestedPartyRole;

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


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

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


SWIGINTERN VALUE _wrap_new_RequestedPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RequestedPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RequestedPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RequestedPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RequestedPartyRole(FIX::RequestedPartyRole *arg1) {
    delete arg1;
}

swig_class cEventTime;

SWIGINTERN VALUE
_wrap_new_EventTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EventTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  
  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 ;
  FIX::EventTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  
  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), "in method '" "FIX::EventTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::EventTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::EventTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventTime";
  
  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), "in method '" "FIX::EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::EventTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EventTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EventTime(FIX::EventTime *arg1) {
    delete arg1;
}

swig_class cRootPartySubIDType;

SWIGINTERN VALUE
_wrap_new_RootPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RootPartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubIDType";
  
  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 ;
  FIX::RootPartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RootPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RootPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RootPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartySubIDType(FIX::RootPartySubIDType *arg1) {
    delete arg1;
}

swig_class cShortSaleReason;

SWIGINTERN VALUE
_wrap_new_ShortSaleReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ShortSaleReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ShortSaleReason";
  
  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 ;
  FIX::ShortSaleReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ShortSaleReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ShortSaleReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ShortSaleReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ShortSaleReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ShortSaleReason(FIX::ShortSaleReason *arg1) {
    delete arg1;
}

swig_class cXmlData;

SWIGINTERN VALUE
_wrap_new_XmlData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::XmlData *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::XmlData";
  
  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 ;
  FIX::XmlData *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::XmlData";
  
  if ((argc < 1) || (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), "in method '" "FIX::XmlData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::XmlData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_XmlData'");
  return Qnil;
}


SWIGINTERN void
free_FIX_XmlData(FIX::XmlData *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSeniority;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSeniority(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSeniority__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSeniority__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSeniority'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSeniority(FIX::RelationshipRiskSeniority *arg1) {
    delete arg1;
}

swig_class cNoTargetPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoTargetPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTargetPartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTargetPartyIDs";
  
  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 ;
  FIX::NoTargetPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTargetPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTargetPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTargetPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTargetPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTargetPartyIDs(FIX::NoTargetPartyIDs *arg1) {
    delete arg1;
}

swig_class cNoRootPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoRootPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoRootPartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartyIDs";
  
  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 ;
  FIX::NoRootPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRootPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRootPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRootPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRootPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRootPartyIDs(FIX::NoRootPartyIDs *arg1) {
    delete arg1;
}

swig_class cEventDate;

SWIGINTERN VALUE
_wrap_new_EventDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EventDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventDate";
  
  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 ;
  FIX::EventDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::EventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EventDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EventDate(FIX::EventDate *arg1) {
    delete arg1;
}

swig_class cPegRoundDirection;

SWIGINTERN VALUE
_wrap_new_PegRoundDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegRoundDirection *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegRoundDirection";
  
  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 ;
  FIX::PegRoundDirection *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegRoundDirection";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegRoundDirection'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegRoundDirection(FIX::PegRoundDirection *arg1) {
    delete arg1;
}

swig_class cLegSettlDate;

SWIGINTERN VALUE
_wrap_new_LegSettlDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSettlDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlDate";
  
  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 ;
  FIX::LegSettlDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSettlDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegSettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSettlDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSettlDate(FIX::LegSettlDate *arg1) {
    delete arg1;
}

swig_class cModelType;

SWIGINTERN VALUE
_wrap_new_ModelType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ModelType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ModelType";
  
  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 ;
  FIX::ModelType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ModelType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ModelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ModelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ModelType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ModelType(FIX::ModelType *arg1) {
    delete arg1;
}

swig_class cDefaultVerIndicator;

SWIGINTERN VALUE
_wrap_new_DefaultVerIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DefaultVerIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultVerIndicator";
  
  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 ;
  FIX::DefaultVerIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultVerIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::DefaultVerIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DefaultVerIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DefaultVerIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultVerIndicator(FIX::DefaultVerIndicator *arg1) {
    delete arg1;
}

swig_class cFuturesValuationMethod;

SWIGINTERN VALUE
_wrap_new_FuturesValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FuturesValuationMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FuturesValuationMethod";
  
  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 ;
  FIX::FuturesValuationMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FuturesValuationMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::FuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FuturesValuationMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FuturesValuationMethod(FIX::FuturesValuationMethod *arg1) {
    delete arg1;
}

swig_class cSettlMethod;

SWIGINTERN VALUE
_wrap_new_SettlMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlMethod";
  
  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 ;
  FIX::SettlMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlMethod(FIX::SettlMethod *arg1) {
    delete arg1;
}

swig_class cUnderlyingFXRate;

SWIGINTERN VALUE
_wrap_new_UnderlyingFXRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingFXRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRate";
  
  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 ;
  FIX::UnderlyingFXRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingFXRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingFXRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingFXRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFXRate(FIX::UnderlyingFXRate *arg1) {
    delete arg1;
}

swig_class cConfirmStatus;

SWIGINTERN VALUE
_wrap_new_ConfirmStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ConfirmStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmStatus";
  
  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 ;
  FIX::ConfirmStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ConfirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfirmStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmStatus(FIX::ConfirmStatus *arg1) {
    delete arg1;
}

swig_class cLocateReqd;

SWIGINTERN VALUE
_wrap_new_LocateReqd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LocateReqd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocateReqd";
  
  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 ;
  FIX::LocateReqd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocateReqd";
  
  if ((argc < 1) || (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), "in method '" "FIX::LocateReqd" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LocateReqd" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LocateReqd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LocateReqd(FIX::LocateReqd *arg1) {
    delete arg1;
}

swig_class cPosMaintRptID;

SWIGINTERN VALUE
_wrap_new_PosMaintRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosMaintRptID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptID";
  
  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 ;
  FIX::PosMaintRptID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosMaintRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosMaintRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosMaintRptID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintRptID(FIX::PosMaintRptID *arg1) {
    delete arg1;
}

swig_class cAdjustment;

SWIGINTERN VALUE
_wrap_new_Adjustment__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Adjustment *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Adjustment";
  
  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 ;
  FIX::Adjustment *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Adjustment";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Adjustment" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Adjustment" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Adjustment'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Adjustment(FIX::Adjustment *arg1) {
    delete arg1;
}

swig_class cStreamAsgnType;

SWIGINTERN VALUE
_wrap_new_StreamAsgnType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StreamAsgnType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnType";
  
  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 ;
  FIX::StreamAsgnType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StreamAsgnType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StreamAsgnType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StreamAsgnType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnType(FIX::StreamAsgnType *arg1) {
    delete arg1;
}

swig_class cLastRptRequested;

SWIGINTERN VALUE
_wrap_new_LastRptRequested__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastRptRequested *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastRptRequested";
  
  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 ;
  FIX::LastRptRequested *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastRptRequested";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastRptRequested" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastRptRequested" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastRptRequested'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastRptRequested(FIX::LastRptRequested *arg1) {
    delete arg1;
}

swig_class cLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_LocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LocaleOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocaleOfIssue";
  
  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 ;
  FIX::LocaleOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LocaleOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LocaleOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LocaleOfIssue(FIX::LocaleOfIssue *arg1) {
    delete arg1;
}

swig_class cSenderSubID;

SWIGINTERN VALUE
_wrap_new_SenderSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SenderSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderSubID";
  
  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 ;
  FIX::SenderSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SenderSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SenderSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SenderSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SenderSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SenderSubID(FIX::SenderSubID *arg1) {
    delete arg1;
}

swig_class cHighPx;

SWIGINTERN VALUE
_wrap_new_HighPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HighPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HighPx";
  
  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 ;
  FIX::HighPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HighPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::HighPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HighPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HighPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HighPx(FIX::HighPx *arg1) {
    delete arg1;
}

swig_class cAllocSettlCurrAmt;

SWIGINTERN VALUE
_wrap_new_AllocSettlCurrAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocSettlCurrAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrAmt";
  
  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 ;
  FIX::AllocSettlCurrAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocSettlCurrAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocSettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocSettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocSettlCurrAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocSettlCurrAmt(FIX::AllocSettlCurrAmt *arg1) {
    delete arg1;
}

swig_class cComplexEventPriceBoundaryPrecision;

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventPriceBoundaryPrecision *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryPrecision";
  
  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 ;
  FIX::ComplexEventPriceBoundaryPrecision *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceBoundaryPrecision";
  
  if ((argc < 1) || (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), "in method '" "FIX::ComplexEventPriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventPriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventPriceBoundaryPrecision'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPriceBoundaryPrecision(FIX::ComplexEventPriceBoundaryPrecision *arg1) {
    delete arg1;
}

swig_class cInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_InstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrumentPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyRole";
  
  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 ;
  FIX::InstrumentPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrumentPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartyRole(FIX::InstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class cYieldRedemptionPrice;

SWIGINTERN VALUE
_wrap_new_YieldRedemptionPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::YieldRedemptionPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPrice";
  
  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 ;
  FIX::YieldRedemptionPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::YieldRedemptionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::YieldRedemptionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_YieldRedemptionPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldRedemptionPrice(FIX::YieldRedemptionPrice *arg1) {
    delete arg1;
}

swig_class cCumQty;

SWIGINTERN VALUE
_wrap_new_CumQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CumQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CumQty";
  
  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 ;
  FIX::CumQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CumQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::CumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CumQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CumQty(FIX::CumQty *arg1) {
    delete arg1;
}

swig_class cOrigClOrdID;

SWIGINTERN VALUE
_wrap_new_OrigClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigClOrdID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigClOrdID";
  
  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 ;
  FIX::OrigClOrdID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigClOrdID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigClOrdID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigClOrdID(FIX::OrigClOrdID *arg1) {
    delete arg1;
}

swig_class cSettlSessID;

SWIGINTERN VALUE
_wrap_new_SettlSessID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlSessID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlSessID";
  
  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 ;
  FIX::SettlSessID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlSessID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlSessID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlSessID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlSessID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlSessID(FIX::SettlSessID *arg1) {
    delete arg1;
}

swig_class cParentMktSegmID;

SWIGINTERN VALUE
_wrap_new_ParentMktSegmID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ParentMktSegmID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ParentMktSegmID";
  
  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 ;
  FIX::ParentMktSegmID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ParentMktSegmID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ParentMktSegmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ParentMktSegmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ParentMktSegmID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ParentMktSegmID(FIX::ParentMktSegmID *arg1) {
    delete arg1;
}

swig_class cTradeReportType;

SWIGINTERN VALUE
_wrap_new_TradeReportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeReportType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportType";
  
  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 ;
  FIX::TradeReportType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeReportType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradeReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeReportType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeReportType(FIX::TradeReportType *arg1) {
    delete arg1;
}

swig_class cAvgPrxPrecision;

SWIGINTERN VALUE
_wrap_new_AvgPrxPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AvgPrxPrecision *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPrxPrecision";
  
  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 ;
  FIX::AvgPrxPrecision *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPrxPrecision";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AvgPrxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AvgPrxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AvgPrxPrecision'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPrxPrecision(FIX::AvgPrxPrecision *arg1) {
    delete arg1;
}

swig_class cNoLegs;

SWIGINTERN VALUE
_wrap_new_NoLegs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoLegs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegs";
  
  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 ;
  FIX::NoLegs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLegs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoLegs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoLegs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoLegs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLegs(FIX::NoLegs *arg1) {
    delete arg1;
}

swig_class cUnderlyingSymbol;

SWIGINTERN VALUE
_wrap_new_UnderlyingSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSymbol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbol";
  
  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 ;
  FIX::UnderlyingSymbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbol";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSymbol(FIX::UnderlyingSymbol *arg1) {
    delete arg1;
}

swig_class cExerciseStyle;

SWIGINTERN VALUE
_wrap_new_ExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExerciseStyle *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExerciseStyle";
  
  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 ;
  FIX::ExerciseStyle *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExerciseStyle";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExerciseStyle'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExerciseStyle(FIX::ExerciseStyle *arg1) {
    delete arg1;
}

swig_class cHaltReasonChar;

SWIGINTERN VALUE
_wrap_new_HaltReasonChar__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HaltReasonChar *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonChar";
  
  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 ;
  FIX::HaltReasonChar *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HaltReasonChar";
  
  if ((argc < 1) || (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), "in method '" "FIX::HaltReasonChar" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HaltReasonChar" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HaltReasonChar'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HaltReasonChar(FIX::HaltReasonChar *arg1) {
    delete arg1;
}

swig_class cExDestination;

SWIGINTERN VALUE
_wrap_new_ExDestination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExDestination *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDestination";
  
  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 ;
  FIX::ExDestination *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDestination";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExDestination" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExDestination" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExDestination'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExDestination(FIX::ExDestination *arg1) {
    delete arg1;
}

swig_class cNoPartyRelationships;

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


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

SWIGINTERN VALUE
_wrap_new_NoPartyRelationships__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyRelationships *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyRelationships";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPartyRelationships" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPartyRelationships" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPartyRelationships *)new FIX::NoPartyRelationships((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPartyRelationships(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPartyRelationships__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_NoPartyRelationships__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPartyRelationships'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartyRelationships(FIX::NoPartyRelationships *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrmtAssignmentMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrmtAssignmentMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrmtAssignmentMethod";
  
  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 ;
  FIX::DerivativeInstrmtAssignmentMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrmtAssignmentMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeInstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrmtAssignmentMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrmtAssignmentMethod(FIX::DerivativeInstrmtAssignmentMethod *arg1) {
    delete arg1;
}

swig_class cUnderlyingIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIDSource";
  
  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 ;
  FIX::UnderlyingIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingIDSource(FIX::UnderlyingIDSource *arg1) {
    delete arg1;
}

swig_class cAdvId;

SWIGINTERN VALUE
_wrap_new_AdvId__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AdvId *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvId";
  
  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 ;
  FIX::AdvId *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvId";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AdvId" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AdvId" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AdvId'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvId(FIX::AdvId *arg1) {
    delete arg1;
}

swig_class cTransBkdTime;

SWIGINTERN VALUE
_wrap_new_TransBkdTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TransBkdTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  
  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 ;
  FIX::TransBkdTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  
  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), "in method '" "FIX::TransBkdTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TransBkdTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TransBkdTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransBkdTime";
  
  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), "in method '" "FIX::TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TransBkdTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TransBkdTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TransBkdTime(FIX::TransBkdTime *arg1) {
    delete arg1;
}

swig_class cLegLastPx;

SWIGINTERN VALUE
_wrap_new_LegLastPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegLastPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastPx";
  
  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 ;
  FIX::LegLastPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegLastPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLastPx(FIX::LegLastPx *arg1) {
    delete arg1;
}

swig_class cNoRiskWarningLevels;

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


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

SWIGINTERN VALUE
_wrap_new_NoRiskWarningLevels__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskWarningLevels *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRiskWarningLevels";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRiskWarningLevels" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRiskWarningLevels *)new FIX::NoRiskWarningLevels((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRiskWarningLevels(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRiskWarningLevels__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_NoRiskWarningLevels__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRiskWarningLevels'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRiskWarningLevels(FIX::NoRiskWarningLevels *arg1) {
    delete arg1;
}

swig_class cAllocReportType;

SWIGINTERN VALUE
_wrap_new_AllocReportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocReportType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportType";
  
  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 ;
  FIX::AllocReportType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocReportType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocReportType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocReportType(FIX::AllocReportType *arg1) {
    delete arg1;
}

swig_class cRegistDtls;

SWIGINTERN VALUE
_wrap_new_RegistDtls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistDtls *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistDtls";
  
  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 ;
  FIX::RegistDtls *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistDtls";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistDtls'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistDtls(FIX::RegistDtls *arg1) {
    delete arg1;
}

swig_class cAllocType;

SWIGINTERN VALUE
_wrap_new_AllocType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocType";
  
  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 ;
  FIX::AllocType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocType(FIX::AllocType *arg1) {
    delete arg1;
}

swig_class cQuoteRequestRejectReason;

SWIGINTERN VALUE
_wrap_new_QuoteRequestRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteRequestRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestRejectReason";
  
  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 ;
  FIX::QuoteRequestRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRequestRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteRequestRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteRequestRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteRequestRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRequestRejectReason(FIX::QuoteRequestRejectReason *arg1) {
    delete arg1;
}

swig_class cUnderlyingUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_UnderlyingUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingUnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasure";
  
  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 ;
  FIX::UnderlyingUnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingUnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingUnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingUnitOfMeasure(FIX::UnderlyingUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cIndividualAllocID;

SWIGINTERN VALUE
_wrap_new_IndividualAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IndividualAllocID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocID";
  
  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 ;
  FIX::IndividualAllocID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IndividualAllocID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IndividualAllocID(FIX::IndividualAllocID *arg1) {
    delete arg1;
}

swig_class cLegOfferPx;

SWIGINTERN VALUE
_wrap_new_LegOfferPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegOfferPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOfferPx";
  
  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 ;
  FIX::LegOfferPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOfferPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegOfferPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOfferPx(FIX::LegOfferPx *arg1) {
    delete arg1;
}

swig_class cLiquidityIndType;

SWIGINTERN VALUE
_wrap_new_LiquidityIndType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LiquidityIndType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityIndType";
  
  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 ;
  FIX::LiquidityIndType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityIndType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LiquidityIndType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LiquidityIndType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LiquidityIndType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityIndType(FIX::LiquidityIndType *arg1) {
    delete arg1;
}

swig_class cHopSendingTime;

SWIGINTERN VALUE
_wrap_new_HopSendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HopSendingTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  
  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 ;
  FIX::HopSendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  
  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), "in method '" "FIX::HopSendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::HopSendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::HopSendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopSendingTime";
  
  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), "in method '" "FIX::HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::HopSendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HopSendingTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HopSendingTime(FIX::HopSendingTime *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskLimitAmount;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskLimitAmount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::AMT *arg1 = 0 ;
  FIX::RelationshipRiskLimitAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskLimitAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskLimitAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  result = (FIX::RelationshipRiskLimitAmount *)new FIX::RelationshipRiskLimitAmount((FIX::AMT const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskLimitAmount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskLimitAmount__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_RelationshipRiskLimitAmount__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskLimitAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskLimitAmount(FIX::RelationshipRiskLimitAmount *arg1) {
    delete arg1;
}

swig_class cApplResendFlag;

SWIGINTERN VALUE
_wrap_new_ApplResendFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplResendFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResendFlag";
  
  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 ;
  FIX::ApplResendFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResendFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::ApplResendFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplResendFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplResendFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResendFlag(FIX::ApplResendFlag *arg1) {
    delete arg1;
}

swig_class cDerivativeCapPrice;

SWIGINTERN VALUE
_wrap_new_DerivativeCapPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeCapPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCapPrice";
  
  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 ;
  FIX::DerivativeCapPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeCapPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeCapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeCapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeCapPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeCapPrice(FIX::DerivativeCapPrice *arg1) {
    delete arg1;
}

swig_class cRiskSecurityID;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityID(FIX::RiskSecurityID *arg1) {
    delete arg1;
}

swig_class cComplexOptPayoutAmount;

SWIGINTERN VALUE
_wrap_new_ComplexOptPayoutAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexOptPayoutAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexOptPayoutAmount";
  
  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 ;
  FIX::ComplexOptPayoutAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexOptPayoutAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::ComplexOptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexOptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexOptPayoutAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexOptPayoutAmount(FIX::ComplexOptPayoutAmount *arg1) {
    delete arg1;
}

swig_class cLanguageCode;

SWIGINTERN VALUE
_wrap_new_LanguageCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LanguageCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LanguageCode";
  
  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 ;
  FIX::LanguageCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LanguageCode";
  
  if ((argc < 1) || (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), "in method '" "FIX::LanguageCode" "', argument " "1"" of type '" "FIX::LANGUAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LanguageCode" "', argument " "1"" of type '" "FIX::LANGUAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LanguageCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LanguageCode(FIX::LanguageCode *arg1) {
    delete arg1;
}

swig_class cSettlObligRefID;

SWIGINTERN VALUE
_wrap_new_SettlObligRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlObligRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligRefID";
  
  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 ;
  FIX::SettlObligRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlObligRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlObligRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlObligRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligRefID(FIX::SettlObligRefID *arg1) {
    delete arg1;
}

swig_class cOrigTradeID;

SWIGINTERN VALUE
_wrap_new_OrigTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigTradeID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeID";
  
  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 ;
  FIX::OrigTradeID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigTradeID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrigTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigTradeID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigTradeID(FIX::OrigTradeID *arg1) {
    delete arg1;
}

swig_class cUnderlyingCollectAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingCollectAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCollectAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCollectAmount";
  
  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 ;
  FIX::UnderlyingCollectAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCollectAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingCollectAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCollectAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCollectAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCollectAmount(FIX::UnderlyingCollectAmount *arg1) {
    delete arg1;
}

swig_class cStatusValue;

SWIGINTERN VALUE
_wrap_new_StatusValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StatusValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatusValue";
  
  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 ;
  FIX::StatusValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatusValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StatusValue" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StatusValue" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StatusValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StatusValue(FIX::StatusValue *arg1) {
    delete arg1;
}

swig_class cOfferSpotRate;

SWIGINTERN VALUE
_wrap_new_OfferSpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OfferSpotRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSpotRate";
  
  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 ;
  FIX::OfferSpotRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OfferSpotRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::OfferSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OfferSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OfferSpotRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OfferSpotRate(FIX::OfferSpotRate *arg1) {
    delete arg1;
}

swig_class cPosType;

SWIGINTERN VALUE
_wrap_new_PosType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosType";
  
  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 ;
  FIX::PosType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosType(FIX::PosType *arg1) {
    delete arg1;
}

swig_class cUnderlyingRedemptionDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingRedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingRedemptionDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRedemptionDate";
  
  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 ;
  FIX::UnderlyingRedemptionDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRedemptionDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingRedemptionDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRedemptionDate(FIX::UnderlyingRedemptionDate *arg1) {
    delete arg1;
}

swig_class cSettlDepositoryCode;

SWIGINTERN VALUE
_wrap_new_SettlDepositoryCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlDepositoryCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDepositoryCode";
  
  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 ;
  FIX::SettlDepositoryCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDepositoryCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlDepositoryCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlDepositoryCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlDepositoryCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDepositoryCode(FIX::SettlDepositoryCode *arg1) {
    delete arg1;
}

swig_class cStreamAsgnAckType;

SWIGINTERN VALUE
_wrap_new_StreamAsgnAckType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StreamAsgnAckType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnAckType";
  
  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 ;
  FIX::StreamAsgnAckType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StreamAsgnAckType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StreamAsgnAckType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StreamAsgnAckType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StreamAsgnAckType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StreamAsgnAckType(FIX::StreamAsgnAckType *arg1) {
    delete arg1;
}

swig_class cFloorPrice;

SWIGINTERN VALUE
_wrap_new_FloorPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FloorPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FloorPrice";
  
  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 ;
  FIX::FloorPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FloorPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::FloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FloorPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FloorPrice(FIX::FloorPrice *arg1) {
    delete arg1;
}

swig_class cRiskMaturityTime;

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


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

SWIGINTERN VALUE
_wrap_new_RiskMaturityTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::TZTIMEONLY *arg1 = 0 ;
  FIX::RiskMaturityTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskMaturityTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  result = (FIX::RiskMaturityTime *)new FIX::RiskMaturityTime((FIX::TZTIMEONLY const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskMaturityTime(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskMaturityTime__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_RiskMaturityTime__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskMaturityTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskMaturityTime(FIX::RiskMaturityTime *arg1) {
    delete arg1;
}

swig_class cUnderlyingPriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingPriceUnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasureQty";
  
  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 ;
  FIX::UnderlyingPriceUnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingPriceUnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPriceUnitOfMeasureQty(FIX::UnderlyingPriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cFeeMultiplier;

SWIGINTERN VALUE
_wrap_new_FeeMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FeeMultiplier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FeeMultiplier";
  
  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 ;
  FIX::FeeMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FeeMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::FeeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FeeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FeeMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FeeMultiplier(FIX::FeeMultiplier *arg1) {
    delete arg1;
}

swig_class cUnderlyingMaturityTime;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingMaturityTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityTime";
  
  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 ;
  FIX::UnderlyingMaturityTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingMaturityTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityTime(FIX::UnderlyingMaturityTime *arg1) {
    delete arg1;
}

swig_class cApplID;

SWIGINTERN VALUE
_wrap_new_ApplID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplID";
  
  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 ;
  FIX::ApplID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplID(FIX::ApplID *arg1) {
    delete arg1;
}

swig_class cLegGrossTradeAmt;

SWIGINTERN VALUE
_wrap_new_LegGrossTradeAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegGrossTradeAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegGrossTradeAmt";
  
  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 ;
  FIX::LegGrossTradeAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegGrossTradeAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegGrossTradeAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegGrossTradeAmt(FIX::LegGrossTradeAmt *arg1) {
    delete arg1;
}

swig_class cMDEntryDate;

SWIGINTERN VALUE
_wrap_new_MDEntryDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryDate";
  
  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 ;
  FIX::MDEntryDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDEntryDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryDate(FIX::MDEntryDate *arg1) {
    delete arg1;
}

swig_class cLegBenchmarkCurveCurrency;

SWIGINTERN VALUE
_wrap_new_LegBenchmarkCurveCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegBenchmarkCurveCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveCurrency";
  
  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 ;
  FIX::LegBenchmarkCurveCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBenchmarkCurveCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegBenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegBenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegBenchmarkCurveCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBenchmarkCurveCurrency(FIX::LegBenchmarkCurveCurrency *arg1) {
    delete arg1;
}

swig_class cRiskInstrumentOperator;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskInstrumentOperator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskInstrumentOperator__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskInstrumentOperator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskInstrumentOperator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskInstrumentOperator(FIX::RiskInstrumentOperator *arg1) {
    delete arg1;
}

swig_class cOptPayoutAmount;

SWIGINTERN VALUE
_wrap_new_OptPayoutAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OptPayoutAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutAmount";
  
  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 ;
  FIX::OptPayoutAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::OptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OptPayoutAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OptPayoutAmount(FIX::OptPayoutAmount *arg1) {
    delete arg1;
}

swig_class cMiscFeeBasis;

SWIGINTERN VALUE
_wrap_new_MiscFeeBasis__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MiscFeeBasis *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeBasis";
  
  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 ;
  FIX::MiscFeeBasis *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MiscFeeBasis";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MiscFeeBasis" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MiscFeeBasis" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MiscFeeBasis'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MiscFeeBasis(FIX::MiscFeeBasis *arg1) {
    delete arg1;
}

swig_class cValidUntilTime;

SWIGINTERN VALUE
_wrap_new_ValidUntilTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ValidUntilTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  
  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 ;
  FIX::ValidUntilTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  
  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), "in method '" "FIX::ValidUntilTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::ValidUntilTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::ValidUntilTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ValidUntilTime";
  
  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), "in method '" "FIX::ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ValidUntilTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ValidUntilTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ValidUntilTime(FIX::ValidUntilTime *arg1) {
    delete arg1;
}

swig_class cOrdType;

SWIGINTERN VALUE
_wrap_new_OrdType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrdType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdType";
  
  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 ;
  FIX::OrdType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrdType";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrdType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrdType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrdType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrdType(FIX::OrdType *arg1) {
    delete arg1;
}

swig_class cAdvRefID;

SWIGINTERN VALUE
_wrap_new_AdvRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AdvRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvRefID";
  
  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 ;
  FIX::AdvRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AdvRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AdvRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AdvRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AdvRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AdvRefID(FIX::AdvRefID *arg1) {
    delete arg1;
}

swig_class cHopCompID;

SWIGINTERN VALUE
_wrap_new_HopCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::HopCompID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopCompID";
  
  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 ;
  FIX::HopCompID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::HopCompID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::HopCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::HopCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_HopCompID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_HopCompID(FIX::HopCompID *arg1) {
    delete arg1;
}

swig_class cPosMaintRptRefID;

SWIGINTERN VALUE
_wrap_new_PosMaintRptRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosMaintRptRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptRefID";
  
  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 ;
  FIX::PosMaintRptRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintRptRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosMaintRptRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosMaintRptRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosMaintRptRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintRptRefID(FIX::PosMaintRptRefID *arg1) {
    delete arg1;
}

swig_class cLegStipulationValue;

SWIGINTERN VALUE
_wrap_new_LegStipulationValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegStipulationValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationValue";
  
  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 ;
  FIX::LegStipulationValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStipulationValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegStipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegStipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegStipulationValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStipulationValue(FIX::LegStipulationValue *arg1) {
    delete arg1;
}

swig_class cMatchType;

SWIGINTERN VALUE
_wrap_new_MatchType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MatchType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchType";
  
  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 ;
  FIX::MatchType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MatchType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MatchType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MatchType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchType(FIX::MatchType *arg1) {
    delete arg1;
}

swig_class cOptPayoutType;

SWIGINTERN VALUE
_wrap_new_OptPayoutType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OptPayoutType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutType";
  
  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 ;
  FIX::OptPayoutType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayoutType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OptPayoutType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OptPayoutType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OptPayoutType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OptPayoutType(FIX::OptPayoutType *arg1) {
    delete arg1;
}

swig_class cUnderlyingPriceUnitOfMeasure;

SWIGINTERN VALUE
_wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingPriceUnitOfMeasure *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasure";
  
  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 ;
  FIX::UnderlyingPriceUnitOfMeasure *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPriceUnitOfMeasure";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingPriceUnitOfMeasure'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPriceUnitOfMeasure(FIX::UnderlyingPriceUnitOfMeasure *arg1) {
    delete arg1;
}

swig_class cMarketUpdateAction;

SWIGINTERN VALUE
_wrap_new_MarketUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarketUpdateAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketUpdateAction";
  
  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 ;
  FIX::MarketUpdateAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarketUpdateAction";
  
  if ((argc < 1) || (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), "in method '" "FIX::MarketUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarketUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarketUpdateAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarketUpdateAction(FIX::MarketUpdateAction *arg1) {
    delete arg1;
}

swig_class cCollAsgnRejectReason;

SWIGINTERN VALUE
_wrap_new_CollAsgnRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollAsgnRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRejectReason";
  
  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 ;
  FIX::CollAsgnRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollAsgnRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollAsgnRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollAsgnRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnRejectReason(FIX::CollAsgnRejectReason *arg1) {
    delete arg1;
}

swig_class cPeggedRefPrice;

SWIGINTERN VALUE
_wrap_new_PeggedRefPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PeggedRefPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PeggedRefPrice";
  
  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 ;
  FIX::PeggedRefPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PeggedRefPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::PeggedRefPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PeggedRefPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PeggedRefPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PeggedRefPrice(FIX::PeggedRefPrice *arg1) {
    delete arg1;
}

swig_class cIndividualAllocType;

SWIGINTERN VALUE
_wrap_new_IndividualAllocType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IndividualAllocType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocType";
  
  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 ;
  FIX::IndividualAllocType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IndividualAllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IndividualAllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IndividualAllocType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IndividualAllocType(FIX::IndividualAllocType *arg1) {
    delete arg1;
}

swig_class cEndCash;

SWIGINTERN VALUE
_wrap_new_EndCash__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EndCash *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndCash";
  
  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 ;
  FIX::EndCash *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndCash";
  
  if ((argc < 1) || (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), "in method '" "FIX::EndCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EndCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EndCash'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EndCash(FIX::EndCash *arg1) {
    delete arg1;
}

swig_class cEventText;

SWIGINTERN VALUE
_wrap_new_EventText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EventText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventText";
  
  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 ;
  FIX::EventText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EventText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::EventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EventText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EventText(FIX::EventText *arg1) {
    delete arg1;
}

swig_class cExDate;

SWIGINTERN VALUE
_wrap_new_ExDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDate";
  
  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 ;
  FIX::ExDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExDate(FIX::ExDate *arg1) {
    delete arg1;
}

swig_class cNestedPartyIDSource;

SWIGINTERN VALUE
_wrap_new_NestedPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NestedPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyIDSource";
  
  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 ;
  FIX::NestedPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::NestedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NestedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NestedPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedPartyIDSource(FIX::NestedPartyIDSource *arg1) {
    delete arg1;
}

swig_class cGTBookingInst;

SWIGINTERN VALUE
_wrap_new_GTBookingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::GTBookingInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GTBookingInst";
  
  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 ;
  FIX::GTBookingInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GTBookingInst";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::GTBookingInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::GTBookingInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_GTBookingInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_GTBookingInst(FIX::GTBookingInst *arg1) {
    delete arg1;
}

swig_class cDerivativeValuationMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeValuationMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeValuationMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeValuationMethod";
  
  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 ;
  FIX::DerivativeValuationMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeValuationMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeValuationMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeValuationMethod(FIX::DerivativeValuationMethod *arg1) {
    delete arg1;
}

swig_class cNumberOfOrders;

SWIGINTERN VALUE
_wrap_new_NumberOfOrders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NumberOfOrders *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumberOfOrders";
  
  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 ;
  FIX::NumberOfOrders *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumberOfOrders";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NumberOfOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NumberOfOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NumberOfOrders'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NumberOfOrders(FIX::NumberOfOrders *arg1) {
    delete arg1;
}

swig_class cTrdRepPartyRole;

SWIGINTERN VALUE
_wrap_new_TrdRepPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdRepPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRepPartyRole";
  
  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 ;
  FIX::TrdRepPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRepPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TrdRepPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdRepPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdRepPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRepPartyRole(FIX::TrdRepPartyRole *arg1) {
    delete arg1;
}

swig_class cTriggerPrice;

SWIGINTERN VALUE
_wrap_new_TriggerPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPrice";
  
  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 ;
  FIX::TriggerPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerPrice(FIX::TriggerPrice *arg1) {
    delete arg1;
}

swig_class cMDReportID;

SWIGINTERN VALUE
_wrap_new_MDReportID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDReportID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReportID";
  
  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 ;
  FIX::MDReportID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReportID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDReportID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDReportID(FIX::MDReportID *arg1) {
    delete arg1;
}

swig_class cSecondaryAllocID;

SWIGINTERN VALUE
_wrap_new_SecondaryAllocID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryAllocID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryAllocID";
  
  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 ;
  FIX::SecondaryAllocID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryAllocID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryAllocID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryAllocID(FIX::SecondaryAllocID *arg1) {
    delete arg1;
}

swig_class cLeavesQty;

SWIGINTERN VALUE
_wrap_new_LeavesQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LeavesQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LeavesQty";
  
  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 ;
  FIX::LeavesQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LeavesQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LeavesQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LeavesQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LeavesQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LeavesQty(FIX::LeavesQty *arg1) {
    delete arg1;
}

swig_class cCardStartDate;

SWIGINTERN VALUE
_wrap_new_CardStartDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CardStartDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardStartDate";
  
  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 ;
  FIX::CardStartDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CardStartDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::CardStartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CardStartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CardStartDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CardStartDate(FIX::CardStartDate *arg1) {
    delete arg1;
}

swig_class cLegCoveredOrUncovered;

SWIGINTERN VALUE
_wrap_new_LegCoveredOrUncovered__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCoveredOrUncovered *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCoveredOrUncovered";
  
  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 ;
  FIX::LegCoveredOrUncovered *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCoveredOrUncovered";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegCoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCoveredOrUncovered'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCoveredOrUncovered(FIX::LegCoveredOrUncovered *arg1) {
    delete arg1;
}

swig_class cPutOrCall;

SWIGINTERN VALUE
_wrap_new_PutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PutOrCall *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PutOrCall";
  
  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 ;
  FIX::PutOrCall *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PutOrCall";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PutOrCall'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PutOrCall(FIX::PutOrCall *arg1) {
    delete arg1;
}

swig_class cMatchAlgorithm;

SWIGINTERN VALUE
_wrap_new_MatchAlgorithm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MatchAlgorithm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchAlgorithm";
  
  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 ;
  FIX::MatchAlgorithm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchAlgorithm";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MatchAlgorithm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MatchAlgorithm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MatchAlgorithm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchAlgorithm(FIX::MatchAlgorithm *arg1) {
    delete arg1;
}

swig_class cCalculatedCcyLastQty;

SWIGINTERN VALUE
_wrap_new_CalculatedCcyLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CalculatedCcyLastQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CalculatedCcyLastQty";
  
  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 ;
  FIX::CalculatedCcyLastQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CalculatedCcyLastQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::CalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CalculatedCcyLastQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CalculatedCcyLastQty(FIX::CalculatedCcyLastQty *arg1) {
    delete arg1;
}

swig_class cFundRenewWaiv;

SWIGINTERN VALUE
_wrap_new_FundRenewWaiv__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FundRenewWaiv *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FundRenewWaiv";
  
  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 ;
  FIX::FundRenewWaiv *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FundRenewWaiv";
  
  if ((argc < 1) || (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), "in method '" "FIX::FundRenewWaiv" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FundRenewWaiv" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FundRenewWaiv'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FundRenewWaiv(FIX::FundRenewWaiv *arg1) {
    delete arg1;
}

swig_class cSecuritySettlAgentName;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecuritySettlAgentName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentName";
  
  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 ;
  FIX::SecuritySettlAgentName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecuritySettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecuritySettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecuritySettlAgentName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentName(FIX::SecuritySettlAgentName *arg1) {
    delete arg1;
}

swig_class cBidDescriptor;

SWIGINTERN VALUE
_wrap_new_BidDescriptor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidDescriptor *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptor";
  
  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 ;
  FIX::BidDescriptor *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptor";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BidDescriptor" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidDescriptor" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidDescriptor'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidDescriptor(FIX::BidDescriptor *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityAltIDSource;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityAltIDSource__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecurityAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityAltIDSource(FIX::RelationshipRiskSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class cMDStreamID;

SWIGINTERN VALUE
_wrap_new_MDStreamID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDStreamID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDStreamID";
  
  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 ;
  FIX::MDStreamID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDStreamID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDStreamID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDStreamID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDStreamID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDStreamID(FIX::MDStreamID *arg1) {
    delete arg1;
}

swig_class cNoAsgnReqs;

SWIGINTERN VALUE
_wrap_new_NoAsgnReqs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoAsgnReqs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAsgnReqs";
  
  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 ;
  FIX::NoAsgnReqs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAsgnReqs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoAsgnReqs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoAsgnReqs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoAsgnReqs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAsgnReqs(FIX::NoAsgnReqs *arg1) {
    delete arg1;
}

swig_class cNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_NotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NotionalPercentageOutstanding *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotionalPercentageOutstanding";
  
  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 ;
  FIX::NotionalPercentageOutstanding *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotionalPercentageOutstanding";
  
  if ((argc < 1) || (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), "in method '" "FIX::NotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NotionalPercentageOutstanding'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NotionalPercentageOutstanding(FIX::NotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class cNoSettlInst;

SWIGINTERN VALUE
_wrap_new_NoSettlInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSettlInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlInst";
  
  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 ;
  FIX::NoSettlInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSettlInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSettlInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSettlInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlInst(FIX::NoSettlInst *arg1) {
    delete arg1;
}

swig_class cSettlInstMsgID;

SWIGINTERN VALUE
_wrap_new_SettlInstMsgID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlInstMsgID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMsgID";
  
  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 ;
  FIX::SettlInstMsgID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlInstMsgID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlInstMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlInstMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlInstMsgID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlInstMsgID(FIX::SettlInstMsgID *arg1) {
    delete arg1;
}

swig_class cForexReq;

SWIGINTERN VALUE
_wrap_new_ForexReq__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ForexReq *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ForexReq";
  
  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 ;
  FIX::ForexReq *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ForexReq";
  
  if ((argc < 1) || (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), "in method '" "FIX::ForexReq" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ForexReq" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ForexReq'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ForexReq(FIX::ForexReq *arg1) {
    delete arg1;
}

swig_class cTradSesReqID;

SWIGINTERN VALUE
_wrap_new_TradSesReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesReqID";
  
  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 ;
  FIX::TradSesReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradSesReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesReqID(FIX::TradSesReqID *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegStrikePrice;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegStrikePrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegStrikePrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegStrikePrice";
  
  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 ;
  FIX::UnderlyingLegStrikePrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegStrikePrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingLegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegStrikePrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegStrikePrice(FIX::UnderlyingLegStrikePrice *arg1) {
    delete arg1;
}

swig_class cTickRuleType;

SWIGINTERN VALUE
_wrap_new_TickRuleType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TickRuleType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickRuleType";
  
  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 ;
  FIX::TickRuleType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TickRuleType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TickRuleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TickRuleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TickRuleType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TickRuleType(FIX::TickRuleType *arg1) {
    delete arg1;
}

swig_class cInstrmtAssignmentMethod;

SWIGINTERN VALUE
_wrap_new_InstrmtAssignmentMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrmtAssignmentMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrmtAssignmentMethod";
  
  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 ;
  FIX::InstrmtAssignmentMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrmtAssignmentMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::InstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrmtAssignmentMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrmtAssignmentMethod(FIX::InstrmtAssignmentMethod *arg1) {
    delete arg1;
}

swig_class cDiscretionOffsetType;

SWIGINTERN VALUE
_wrap_new_DiscretionOffsetType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionOffsetType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetType";
  
  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 ;
  FIX::DiscretionOffsetType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DiscretionOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionOffsetType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionOffsetType(FIX::DiscretionOffsetType *arg1) {
    delete arg1;
}

swig_class cConfirmTransType;

SWIGINTERN VALUE
_wrap_new_ConfirmTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ConfirmTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmTransType";
  
  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 ;
  FIX::ConfirmTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ConfirmTransType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ConfirmTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ConfirmTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ConfirmTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ConfirmTransType(FIX::ConfirmTransType *arg1) {
    delete arg1;
}

swig_class cTotalTakedown;

SWIGINTERN VALUE
_wrap_new_TotalTakedown__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalTakedown *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalTakedown";
  
  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 ;
  FIX::TotalTakedown *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalTakedown";
  
  if ((argc < 1) || (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), "in method '" "FIX::TotalTakedown" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalTakedown" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalTakedown'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalTakedown(FIX::TotalTakedown *arg1) {
    delete arg1;
}

swig_class cResponseDestination;

SWIGINTERN VALUE
_wrap_new_ResponseDestination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ResponseDestination *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResponseDestination";
  
  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 ;
  FIX::ResponseDestination *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ResponseDestination";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ResponseDestination" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ResponseDestination" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ResponseDestination'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ResponseDestination(FIX::ResponseDestination *arg1) {
    delete arg1;
}

swig_class cMDSecSizeType;

SWIGINTERN VALUE
_wrap_new_MDSecSizeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDSecSizeType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSecSizeType";
  
  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 ;
  FIX::MDSecSizeType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSecSizeType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDSecSizeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDSecSizeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDSecSizeType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDSecSizeType(FIX::MDSecSizeType *arg1) {
    delete arg1;
}

swig_class cInstrumentPartySubIDType;

SWIGINTERN VALUE
_wrap_new_InstrumentPartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrumentPartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubIDType";
  
  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 ;
  FIX::InstrumentPartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrumentPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartySubIDType(FIX::InstrumentPartySubIDType *arg1) {
    delete arg1;
}

swig_class cLegTimeUnit;

SWIGINTERN VALUE
_wrap_new_LegTimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegTimeUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegTimeUnit";
  
  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 ;
  FIX::LegTimeUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegTimeUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegTimeUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegTimeUnit(FIX::LegTimeUnit *arg1) {
    delete arg1;
}

swig_class cTransferReason;

SWIGINTERN VALUE
_wrap_new_TransferReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TransferReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransferReason";
  
  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 ;
  FIX::TransferReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TransferReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TransferReason" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TransferReason" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TransferReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TransferReason(FIX::TransferReason *arg1) {
    delete arg1;
}

swig_class cApplQueueMax;

SWIGINTERN VALUE
_wrap_new_ApplQueueMax__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplQueueMax *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueMax";
  
  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 ;
  FIX::ApplQueueMax *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueMax";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplQueueMax" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplQueueMax" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplQueueMax'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueMax(FIX::ApplQueueMax *arg1) {
    delete arg1;
}

swig_class cDiscretionOffsetValue;

SWIGINTERN VALUE
_wrap_new_DiscretionOffsetValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionOffsetValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetValue";
  
  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 ;
  FIX::DiscretionOffsetValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionOffsetValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::DiscretionOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionOffsetValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionOffsetValue(FIX::DiscretionOffsetValue *arg1) {
    delete arg1;
}

swig_class cBookingRefID;

SWIGINTERN VALUE
_wrap_new_BookingRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BookingRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingRefID";
  
  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 ;
  FIX::BookingRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BookingRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BookingRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BookingRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BookingRefID(FIX::BookingRefID *arg1) {
    delete arg1;
}

swig_class cLegBidPx;

SWIGINTERN VALUE
_wrap_new_LegBidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegBidPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBidPx";
  
  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 ;
  FIX::LegBidPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBidPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegBidPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBidPx(FIX::LegBidPx *arg1) {
    delete arg1;
}

swig_class cContextPartyRole;

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


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

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


SWIGINTERN VALUE _wrap_new_ContextPartyRole(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContextPartyRole__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContextPartyRole__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContextPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContextPartyRole(FIX::ContextPartyRole *arg1) {
    delete arg1;
}

swig_class cTradSesEvent;

SWIGINTERN VALUE
_wrap_new_TradSesEvent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesEvent *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEvent";
  
  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 ;
  FIX::TradSesEvent *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesEvent";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradSesEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesEvent'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesEvent(FIX::TradSesEvent *arg1) {
    delete arg1;
}

swig_class cDerivativeProduct;

SWIGINTERN VALUE
_wrap_new_DerivativeProduct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeProduct *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProduct";
  
  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 ;
  FIX::DerivativeProduct *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProduct";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeProduct'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeProduct(FIX::DerivativeProduct *arg1) {
    delete arg1;
}

swig_class cRootPartyRole;

SWIGINTERN VALUE
_wrap_new_RootPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RootPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyRole";
  
  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 ;
  FIX::RootPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RootPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RootPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RootPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartyRole(FIX::RootPartyRole *arg1) {
    delete arg1;
}

swig_class cDlvyInstType;

SWIGINTERN VALUE
_wrap_new_DlvyInstType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DlvyInstType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DlvyInstType";
  
  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 ;
  FIX::DlvyInstType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DlvyInstType";
  
  if ((argc < 1) || (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), "in method '" "FIX::DlvyInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DlvyInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DlvyInstType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DlvyInstType(FIX::DlvyInstType *arg1) {
    delete arg1;
}

swig_class cNoLinesOfText;

SWIGINTERN VALUE
_wrap_new_NoLinesOfText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoLinesOfText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLinesOfText";
  
  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 ;
  FIX::NoLinesOfText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoLinesOfText";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoLinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoLinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoLinesOfText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoLinesOfText(FIX::NoLinesOfText *arg1) {
    delete arg1;
}

swig_class cPosReqID;

SWIGINTERN VALUE
_wrap_new_PosReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqID";
  
  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 ;
  FIX::PosReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqID(FIX::PosReqID *arg1) {
    delete arg1;
}

swig_class cLegSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_LegSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSecurityAltIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltIDSource";
  
  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 ;
  FIX::LegSecurityAltIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSecurityAltIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSecurityAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSecurityAltIDSource(FIX::LegSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class cEncodedSubject;

SWIGINTERN VALUE
_wrap_new_EncodedSubject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedSubject *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubject";
  
  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 ;
  FIX::EncodedSubject *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSubject";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSubject" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSubject" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSubject'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSubject(FIX::EncodedSubject *arg1) {
    delete arg1;
}

swig_class cContraBroker;

SWIGINTERN VALUE
_wrap_new_ContraBroker__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContraBroker *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraBroker";
  
  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 ;
  FIX::ContraBroker *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraBroker";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ContraBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContraBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContraBroker'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraBroker(FIX::ContraBroker *arg1) {
    delete arg1;
}

swig_class cTradeCondition;

SWIGINTERN VALUE
_wrap_new_TradeCondition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeCondition *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeCondition";
  
  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 ;
  FIX::TradeCondition *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeCondition";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradeCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeCondition'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeCondition(FIX::TradeCondition *arg1) {
    delete arg1;
}

swig_class cPartyID;

SWIGINTERN VALUE
_wrap_new_PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyID";
  
  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 ;
  FIX::PartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyID(FIX::PartyID *arg1) {
    delete arg1;
}

swig_class cMDEntryID;

SWIGINTERN VALUE
_wrap_new_MDEntryID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryID";
  
  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 ;
  FIX::MDEntryID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryID(FIX::MDEntryID *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecurityExchange;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecurityExchange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityExchange";
  
  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 ;
  FIX::UnderlyingLegSecurityExchange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityExchange";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecurityExchange" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecurityExchange" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecurityExchange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityExchange(FIX::UnderlyingLegSecurityExchange *arg1) {
    delete arg1;
}

swig_class cPriceLimitType;

SWIGINTERN VALUE
_wrap_new_PriceLimitType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceLimitType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceLimitType";
  
  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 ;
  FIX::PriceLimitType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceLimitType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceLimitType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceLimitType(FIX::PriceLimitType *arg1) {
    delete arg1;
}

swig_class cTriggerSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_TriggerSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerSecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityIDSource";
  
  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 ;
  FIX::TriggerSecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TriggerSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSecurityIDSource(FIX::TriggerSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cNoUndlyInstrumentPartySubIDs;

SWIGINTERN VALUE
_wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoUndlyInstrumentPartySubIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentPartySubIDs";
  
  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 ;
  FIX::NoUndlyInstrumentPartySubIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUndlyInstrumentPartySubIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoUndlyInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoUndlyInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoUndlyInstrumentPartySubIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUndlyInstrumentPartySubIDs(FIX::NoUndlyInstrumentPartySubIDs *arg1) {
    delete arg1;
}

swig_class cClientBidID;

SWIGINTERN VALUE
_wrap_new_ClientBidID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ClientBidID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClientBidID";
  
  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 ;
  FIX::ClientBidID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ClientBidID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ClientBidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ClientBidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ClientBidID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ClientBidID(FIX::ClientBidID *arg1) {
    delete arg1;
}

swig_class cNetChgPrevDay;

SWIGINTERN VALUE
_wrap_new_NetChgPrevDay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NetChgPrevDay *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetChgPrevDay";
  
  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 ;
  FIX::NetChgPrevDay *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetChgPrevDay";
  
  if ((argc < 1) || (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), "in method '" "FIX::NetChgPrevDay" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NetChgPrevDay" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetChgPrevDay'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NetChgPrevDay(FIX::NetChgPrevDay *arg1) {
    delete arg1;
}

swig_class cDefaultApplVerID;

SWIGINTERN VALUE
_wrap_new_DefaultApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DefaultApplVerID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplVerID";
  
  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 ;
  FIX::DefaultApplVerID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplVerID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DefaultApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DefaultApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DefaultApplVerID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultApplVerID(FIX::DefaultApplVerID *arg1) {
    delete arg1;
}

swig_class cIOIID;

SWIGINTERN VALUE
_wrap_new_IOIID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIID";
  
  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 ;
  FIX::IOIID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IOIID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIID(FIX::IOIID *arg1) {
    delete arg1;
}

swig_class cSpreadToBenchmark;

SWIGINTERN VALUE
_wrap_new_SpreadToBenchmark__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SpreadToBenchmark *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SpreadToBenchmark";
  
  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 ;
  FIX::SpreadToBenchmark *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SpreadToBenchmark";
  
  if ((argc < 1) || (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), "in method '" "FIX::SpreadToBenchmark" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SpreadToBenchmark" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SpreadToBenchmark'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SpreadToBenchmark(FIX::SpreadToBenchmark *arg1) {
    delete arg1;
}

swig_class cCommType;

SWIGINTERN VALUE
_wrap_new_CommType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CommType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CommType";
  
  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 ;
  FIX::CommType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CommType";
  
  if ((argc < 1) || (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), "in method '" "FIX::CommType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CommType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CommType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CommType(FIX::CommType *arg1) {
    delete arg1;
}

swig_class cRegistRejReasonCode;

SWIGINTERN VALUE
_wrap_new_RegistRejReasonCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistRejReasonCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonCode";
  
  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 ;
  FIX::RegistRejReasonCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistRejReasonCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistRejReasonCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistRejReasonCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistRejReasonCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistRejReasonCode(FIX::RegistRejReasonCode *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskEncodedSecurityDesc;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskEncodedSecurityDesc__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::DATA *arg1 = 0 ;
  FIX::RelationshipRiskEncodedSecurityDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskEncodedSecurityDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  result = (FIX::RelationshipRiskEncodedSecurityDesc *)new FIX::RelationshipRiskEncodedSecurityDesc((FIX::DATA const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskEncodedSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskEncodedSecurityDesc__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_RelationshipRiskEncodedSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskEncodedSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskEncodedSecurityDesc(FIX::RelationshipRiskEncodedSecurityDesc *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskRestructuringType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskRestructuringType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskRestructuringType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskRestructuringType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskRestructuringType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskRestructuringType(FIX::RelationshipRiskRestructuringType *arg1) {
    delete arg1;
}

swig_class cSideTimeInForce;

SWIGINTERN VALUE
_wrap_new_SideTimeInForce__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideTimeInForce *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  
  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 ;
  FIX::SideTimeInForce *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  
  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), "in method '" "FIX::SideTimeInForce" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::SideTimeInForce *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  
  if ((argc < 1) || (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), "in method '" "FIX::SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::SideTimeInForce *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTimeInForce";
  
  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), "in method '" "FIX::SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::SideTimeInForce" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideTimeInForce'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTimeInForce(FIX::SideTimeInForce *arg1) {
    delete arg1;
}

swig_class cTrdRegTimestamp;

SWIGINTERN VALUE
_wrap_new_TrdRegTimestamp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdRegTimestamp *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  
  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 ;
  FIX::TrdRegTimestamp *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  
  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), "in method '" "FIX::TrdRegTimestamp" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::TrdRegTimestamp *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  
  if ((argc < 1) || (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), "in method '" "FIX::TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::TrdRegTimestamp *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestamp";
  
  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), "in method '" "FIX::TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::TrdRegTimestamp" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdRegTimestamp'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRegTimestamp(FIX::TrdRegTimestamp *arg1) {
    delete arg1;
}

swig_class cFinancialStatus;

SWIGINTERN VALUE
_wrap_new_FinancialStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FinancialStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FinancialStatus";
  
  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 ;
  FIX::FinancialStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FinancialStatus";
  
  if ((argc < 1) || (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), "in method '" "FIX::FinancialStatus" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FinancialStatus" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FinancialStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FinancialStatus(FIX::FinancialStatus *arg1) {
    delete arg1;
}

swig_class cNoTrades;

SWIGINTERN VALUE
_wrap_new_NoTrades__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTrades *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrades";
  
  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 ;
  FIX::NoTrades *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrades";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTrades" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTrades" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTrades'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTrades(FIX::NoTrades *arg1) {
    delete arg1;
}

swig_class cLastFragment;

SWIGINTERN VALUE
_wrap_new_LastFragment__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastFragment *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastFragment";
  
  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 ;
  FIX::LastFragment *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastFragment";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastFragment" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastFragment" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastFragment'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastFragment(FIX::LastFragment *arg1) {
    delete arg1;
}

swig_class cPartySubID;

SWIGINTERN VALUE
_wrap_new_PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartySubID";
  
  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 ;
  FIX::PartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartySubID(FIX::PartySubID *arg1) {
    delete arg1;
}

swig_class cAllocQty;

SWIGINTERN VALUE
_wrap_new_AllocQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocQty";
  
  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 ;
  FIX::AllocQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocQty(FIX::AllocQty *arg1) {
    delete arg1;
}

swig_class cNotifyBrokerOfCredit;

SWIGINTERN VALUE
_wrap_new_NotifyBrokerOfCredit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NotifyBrokerOfCredit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotifyBrokerOfCredit";
  
  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 ;
  FIX::NotifyBrokerOfCredit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotifyBrokerOfCredit";
  
  if ((argc < 1) || (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), "in method '" "FIX::NotifyBrokerOfCredit" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NotifyBrokerOfCredit" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NotifyBrokerOfCredit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NotifyBrokerOfCredit(FIX::NotifyBrokerOfCredit *arg1) {
    delete arg1;
}

swig_class cSideTrdRegTimestampType;

SWIGINTERN VALUE
_wrap_new_SideTrdRegTimestampType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideTrdRegTimestampType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampType";
  
  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 ;
  FIX::SideTrdRegTimestampType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideTrdRegTimestampType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideTrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideTrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideTrdRegTimestampType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideTrdRegTimestampType(FIX::SideTrdRegTimestampType *arg1) {
    delete arg1;
}

swig_class cAgreementDate;

SWIGINTERN VALUE
_wrap_new_AgreementDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AgreementDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementDate";
  
  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 ;
  FIX::AgreementDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::AgreementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AgreementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AgreementDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementDate(FIX::AgreementDate *arg1) {
    delete arg1;
}

swig_class cPartySubIDType;

SWIGINTERN VALUE
_wrap_new_PartySubIDType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PartySubIDType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartySubIDType";
  
  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 ;
  FIX::PartySubIDType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartySubIDType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartySubIDType(FIX::PartySubIDType *arg1) {
    delete arg1;
}

swig_class cTotalNetValue;

SWIGINTERN VALUE
_wrap_new_TotalNetValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotalNetValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNetValue";
  
  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 ;
  FIX::TotalNetValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotalNetValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::TotalNetValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotalNetValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotalNetValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotalNetValue(FIX::TotalNetValue *arg1) {
    delete arg1;
}

swig_class cAllocNoOrdersType;

SWIGINTERN VALUE
_wrap_new_AllocNoOrdersType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocNoOrdersType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocNoOrdersType";
  
  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 ;
  FIX::AllocNoOrdersType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocNoOrdersType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocNoOrdersType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocNoOrdersType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocNoOrdersType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocNoOrdersType(FIX::AllocNoOrdersType *arg1) {
    delete arg1;
}

swig_class cAllocLinkID;

SWIGINTERN VALUE
_wrap_new_AllocLinkID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocLinkID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkID";
  
  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 ;
  FIX::AllocLinkID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocLinkID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocLinkID(FIX::AllocLinkID *arg1) {
    delete arg1;
}

swig_class cRoundingModulus;

SWIGINTERN VALUE
_wrap_new_RoundingModulus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RoundingModulus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundingModulus";
  
  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 ;
  FIX::RoundingModulus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RoundingModulus";
  
  if ((argc < 1) || (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), "in method '" "FIX::RoundingModulus" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RoundingModulus" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RoundingModulus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RoundingModulus(FIX::RoundingModulus *arg1) {
    delete arg1;
}

swig_class cOnBehalfOfCompID;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfCompID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OnBehalfOfCompID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfCompID";
  
  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 ;
  FIX::OnBehalfOfCompID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfCompID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OnBehalfOfCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OnBehalfOfCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OnBehalfOfCompID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfCompID(FIX::OnBehalfOfCompID *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecurityID;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityID";
  
  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 ;
  FIX::UnderlyingSecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityID(FIX::UnderlyingSecurityID *arg1) {
    delete arg1;
}

swig_class cSettlObligMsgID;

SWIGINTERN VALUE
_wrap_new_SettlObligMsgID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlObligMsgID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMsgID";
  
  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 ;
  FIX::SettlObligMsgID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligMsgID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlObligMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlObligMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlObligMsgID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligMsgID(FIX::SettlObligMsgID *arg1) {
    delete arg1;
}

swig_class cPositionLimit;

SWIGINTERN VALUE
_wrap_new_PositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PositionLimit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionLimit";
  
  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 ;
  FIX::PositionLimit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PositionLimit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PositionLimit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PositionLimit(FIX::PositionLimit *arg1) {
    delete arg1;
}

swig_class cSharedCommission;

SWIGINTERN VALUE
_wrap_new_SharedCommission__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SharedCommission *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SharedCommission";
  
  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 ;
  FIX::SharedCommission *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SharedCommission";
  
  if ((argc < 1) || (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), "in method '" "FIX::SharedCommission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SharedCommission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SharedCommission'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SharedCommission(FIX::SharedCommission *arg1) {
    delete arg1;
}

swig_class cAllowableOneSidednessPct;

SWIGINTERN VALUE
_wrap_new_AllowableOneSidednessPct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllowableOneSidednessPct *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessPct";
  
  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 ;
  FIX::AllowableOneSidednessPct *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllowableOneSidednessPct";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllowableOneSidednessPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllowableOneSidednessPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllowableOneSidednessPct'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllowableOneSidednessPct(FIX::AllowableOneSidednessPct *arg1) {
    delete arg1;
}

swig_class cAllocText;

SWIGINTERN VALUE
_wrap_new_AllocText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocText";
  
  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 ;
  FIX::AllocText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocText(FIX::AllocText *arg1) {
    delete arg1;
}

swig_class cEndSeqNo;

SWIGINTERN VALUE
_wrap_new_EndSeqNo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EndSeqNo *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndSeqNo";
  
  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 ;
  FIX::EndSeqNo *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndSeqNo";
  
  if ((argc < 1) || (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), "in method '" "FIX::EndSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EndSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EndSeqNo'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EndSeqNo(FIX::EndSeqNo *arg1) {
    delete arg1;
}

swig_class cNoPartyIDs;

SWIGINTERN VALUE
_wrap_new_NoPartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoPartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyIDs";
  
  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 ;
  FIX::NoPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartyIDs(FIX::NoPartyIDs *arg1) {
    delete arg1;
}

swig_class cNoContraBrokers;

SWIGINTERN VALUE
_wrap_new_NoContraBrokers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoContraBrokers *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContraBrokers";
  
  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 ;
  FIX::NoContraBrokers *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoContraBrokers";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoContraBrokers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoContraBrokers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoContraBrokers'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoContraBrokers(FIX::NoContraBrokers *arg1) {
    delete arg1;
}

swig_class cAllocLinkType;

SWIGINTERN VALUE
_wrap_new_AllocLinkType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocLinkType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkType";
  
  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 ;
  FIX::AllocLinkType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocLinkType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocLinkType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocLinkType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocLinkType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocLinkType(FIX::AllocLinkType *arg1) {
    delete arg1;
}

swig_class cUnderlyingAllocationPercent;

SWIGINTERN VALUE
_wrap_new_UnderlyingAllocationPercent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingAllocationPercent *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAllocationPercent";
  
  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 ;
  FIX::UnderlyingAllocationPercent *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingAllocationPercent";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingAllocationPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingAllocationPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingAllocationPercent'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingAllocationPercent(FIX::UnderlyingAllocationPercent *arg1) {
    delete arg1;
}

swig_class cAllocAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_AllocAccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocAccruedInterestAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccruedInterestAmt";
  
  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 ;
  FIX::AllocAccruedInterestAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAccruedInterestAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocAccruedInterestAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAccruedInterestAmt(FIX::AllocAccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class cRiskSecuritySubType;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecuritySubType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecuritySubType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecuritySubType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecuritySubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecuritySubType(FIX::RiskSecuritySubType *arg1) {
    delete arg1;
}

swig_class cEncodedSecurityListDesc;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityListDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedSecurityListDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDesc";
  
  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 ;
  FIX::EncodedSecurityListDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDesc";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSecurityListDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSecurityListDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSecurityListDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityListDesc(FIX::EncodedSecurityListDesc *arg1) {
    delete arg1;
}

swig_class cEncryptedPasswordLen;

SWIGINTERN VALUE
_wrap_new_EncryptedPasswordLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncryptedPasswordLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordLen";
  
  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 ;
  FIX::EncryptedPasswordLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncryptedPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncryptedPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncryptedPasswordLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedPasswordLen(FIX::EncryptedPasswordLen *arg1) {
    delete arg1;
}

swig_class cLegDividendYield;

SWIGINTERN VALUE
_wrap_new_LegDividendYield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegDividendYield *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegDividendYield";
  
  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 ;
  FIX::LegDividendYield *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegDividendYield";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegDividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegDividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegDividendYield'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegDividendYield(FIX::LegDividendYield *arg1) {
    delete arg1;
}

swig_class cRefreshIndicator;

SWIGINTERN VALUE
_wrap_new_RefreshIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefreshIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefreshIndicator";
  
  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 ;
  FIX::RefreshIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefreshIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::RefreshIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefreshIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefreshIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefreshIndicator(FIX::RefreshIndicator *arg1) {
    delete arg1;
}

swig_class cSideSettlCurrency;

SWIGINTERN VALUE
_wrap_new_SideSettlCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideSettlCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideSettlCurrency";
  
  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 ;
  FIX::SideSettlCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideSettlCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::SideSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideSettlCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideSettlCurrency(FIX::SideSettlCurrency *arg1) {
    delete arg1;
}

swig_class cUnderlyingSettlementType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSettlementType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSettlementType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementType";
  
  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 ;
  FIX::UnderlyingSettlementType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSettlementType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSettlementType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSettlementType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSettlementType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSettlementType(FIX::UnderlyingSettlementType *arg1) {
    delete arg1;
}

swig_class cOrderCapacityQty;

SWIGINTERN VALUE
_wrap_new_OrderCapacityQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderCapacityQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacityQty";
  
  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 ;
  FIX::OrderCapacityQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderCapacityQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderCapacityQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderCapacityQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderCapacityQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderCapacityQty(FIX::OrderCapacityQty *arg1) {
    delete arg1;
}

swig_class cLongQty;

SWIGINTERN VALUE
_wrap_new_LongQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LongQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LongQty";
  
  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 ;
  FIX::LongQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LongQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LongQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LongQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LongQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LongQty(FIX::LongQty *arg1) {
    delete arg1;
}

swig_class cNoPartyAltIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoPartyAltIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoPartyAltIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoPartyAltIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoPartyAltIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoPartyAltIDs *)new FIX::NoPartyAltIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoPartyAltIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoPartyAltIDs__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_NoPartyAltIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoPartyAltIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoPartyAltIDs(FIX::NoPartyAltIDs *arg1) {
    delete arg1;
}

swig_class cDerivativeSettlMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeSettlMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSettlMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettlMethod";
  
  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 ;
  FIX::DerivativeSettlMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSettlMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeSettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSettlMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSettlMethod(FIX::DerivativeSettlMethod *arg1) {
    delete arg1;
}

swig_class cTriggerTradingSessionID;

SWIGINTERN VALUE
_wrap_new_TriggerTradingSessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerTradingSessionID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionID";
  
  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 ;
  FIX::TriggerTradingSessionID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerTradingSessionID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TriggerTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerTradingSessionID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerTradingSessionID(FIX::TriggerTradingSessionID *arg1) {
    delete arg1;
}

swig_class cDisplayMethod;

SWIGINTERN VALUE
_wrap_new_DisplayMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DisplayMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayMethod";
  
  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 ;
  FIX::DisplayMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DisplayMethod";
  
  if ((argc < 1) || (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), "in method '" "FIX::DisplayMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DisplayMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DisplayMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DisplayMethod(FIX::DisplayMethod *arg1) {
    delete arg1;
}

swig_class cRptSeq;

SWIGINTERN VALUE
_wrap_new_RptSeq__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RptSeq *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RptSeq";
  
  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 ;
  FIX::RptSeq *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RptSeq";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RptSeq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RptSeq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RptSeq'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RptSeq(FIX::RptSeq *arg1) {
    delete arg1;
}

swig_class cMDEntryOriginator;

SWIGINTERN VALUE
_wrap_new_MDEntryOriginator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDEntryOriginator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryOriginator";
  
  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 ;
  FIX::MDEntryOriginator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDEntryOriginator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDEntryOriginator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDEntryOriginator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDEntryOriginator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDEntryOriginator(FIX::MDEntryOriginator *arg1) {
    delete arg1;
}

swig_class cLegInstrRegistry;

SWIGINTERN VALUE
_wrap_new_LegInstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegInstrRegistry *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegInstrRegistry";
  
  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 ;
  FIX::LegInstrRegistry *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegInstrRegistry";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegInstrRegistry'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegInstrRegistry(FIX::LegInstrRegistry *arg1) {
    delete arg1;
}

swig_class cFillQty;

SWIGINTERN VALUE
_wrap_new_FillQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FillQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillQty";
  
  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 ;
  FIX::FillQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FillQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::FillQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FillQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FillQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FillQty(FIX::FillQty *arg1) {
    delete arg1;
}

swig_class cPegSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_PegSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PegSecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityIDSource";
  
  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 ;
  FIX::PegSecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PegSecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PegSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PegSecurityIDSource(FIX::PegSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cMaturityTime;

SWIGINTERN VALUE
_wrap_new_MaturityTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityTime";
  
  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 ;
  FIX::MaturityTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityTime(FIX::MaturityTime *arg1) {
    delete arg1;
}

swig_class cMDFeedType;

SWIGINTERN VALUE
_wrap_new_MDFeedType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDFeedType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDFeedType";
  
  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 ;
  FIX::MDFeedType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDFeedType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MDFeedType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDFeedType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDFeedType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDFeedType(FIX::MDFeedType *arg1) {
    delete arg1;
}

swig_class cCollStatus;

SWIGINTERN VALUE
_wrap_new_CollStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollStatus";
  
  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 ;
  FIX::CollStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollStatus(FIX::CollStatus *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecuritySubType;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecuritySubType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecuritySubType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecuritySubType";
  
  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 ;
  FIX::UnderlyingSecuritySubType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecuritySubType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecuritySubType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecuritySubType(FIX::UnderlyingSecuritySubType *arg1) {
    delete arg1;
}

swig_class cCstmApplVerID;

SWIGINTERN VALUE
_wrap_new_CstmApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CstmApplVerID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CstmApplVerID";
  
  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 ;
  FIX::CstmApplVerID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CstmApplVerID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CstmApplVerID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CstmApplVerID(FIX::CstmApplVerID *arg1) {
    delete arg1;
}

swig_class cDefaultApplExtID;

SWIGINTERN VALUE
_wrap_new_DefaultApplExtID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DefaultApplExtID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplExtID";
  
  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 ;
  FIX::DefaultApplExtID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultApplExtID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DefaultApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DefaultApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DefaultApplExtID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultApplExtID(FIX::DefaultApplExtID *arg1) {
    delete arg1;
}

swig_class cNoDerivativeSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoDerivativeSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDerivativeSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeSecurityAltID";
  
  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 ;
  FIX::NoDerivativeSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeSecurityAltID";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoDerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDerivativeSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeSecurityAltID(FIX::NoDerivativeSecurityAltID *arg1) {
    delete arg1;
}

swig_class cSideValueInd;

SWIGINTERN VALUE
_wrap_new_SideValueInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideValueInd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValueInd";
  
  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 ;
  FIX::SideValueInd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideValueInd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideValueInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideValueInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideValueInd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideValueInd(FIX::SideValueInd *arg1) {
    delete arg1;
}

swig_class cEncodedText;

SWIGINTERN VALUE
_wrap_new_EncodedText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedText";
  
  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 ;
  FIX::EncodedText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedText";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedText(FIX::EncodedText *arg1) {
    delete arg1;
}

swig_class cAccount;

SWIGINTERN VALUE
_wrap_new_Account__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Account *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Account";
  
  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 ;
  FIX::Account *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Account";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Account" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Account" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Account'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Account(FIX::Account *arg1) {
    delete arg1;
}

swig_class cTriggerNewPrice;

SWIGINTERN VALUE
_wrap_new_TriggerNewPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerNewPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewPrice";
  
  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 ;
  FIX::TriggerNewPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerNewPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerNewPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerNewPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerNewPrice(FIX::TriggerNewPrice *arg1) {
    delete arg1;
}

swig_class cUndlyInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UndlyInstrumentPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyRole";
  
  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 ;
  FIX::UndlyInstrumentPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UndlyInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UndlyInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UndlyInstrumentPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartyRole(FIX::UndlyInstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class cMsgDirection;

SWIGINTERN VALUE
_wrap_new_MsgDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MsgDirection *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgDirection";
  
  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 ;
  FIX::MsgDirection *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgDirection";
  
  if ((argc < 1) || (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), "in method '" "FIX::MsgDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MsgDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MsgDirection'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MsgDirection(FIX::MsgDirection *arg1) {
    delete arg1;
}

swig_class cLegMaturityDate;

SWIGINTERN VALUE
_wrap_new_LegMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegMaturityDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityDate";
  
  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 ;
  FIX::LegMaturityDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegMaturityDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegMaturityDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegMaturityDate(FIX::LegMaturityDate *arg1) {
    delete arg1;
}

swig_class cUnderlyingContractMultiplierUnit;

SWIGINTERN VALUE
_wrap_new_UnderlyingContractMultiplierUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingContractMultiplierUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplierUnit";
  
  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 ;
  FIX::UnderlyingContractMultiplierUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingContractMultiplierUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingContractMultiplierUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingContractMultiplierUnit(FIX::UnderlyingContractMultiplierUnit *arg1) {
    delete arg1;
}

swig_class cInputSource;

SWIGINTERN VALUE
_wrap_new_InputSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InputSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InputSource";
  
  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 ;
  FIX::InputSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InputSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InputSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InputSource(FIX::InputSource *arg1) {
    delete arg1;
}

swig_class cMDUpdateAction;

SWIGINTERN VALUE
_wrap_new_MDUpdateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDUpdateAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateAction";
  
  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 ;
  FIX::MDUpdateAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDUpdateAction";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDUpdateAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDUpdateAction(FIX::MDUpdateAction *arg1) {
    delete arg1;
}

swig_class cMatchStatus;

SWIGINTERN VALUE
_wrap_new_MatchStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MatchStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchStatus";
  
  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 ;
  FIX::MatchStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MatchStatus";
  
  if ((argc < 1) || (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), "in method '" "FIX::MatchStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MatchStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MatchStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MatchStatus(FIX::MatchStatus *arg1) {
    delete arg1;
}

swig_class cRateSource;

SWIGINTERN VALUE
_wrap_new_RateSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RateSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RateSource";
  
  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 ;
  FIX::RateSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RateSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RateSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RateSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RateSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RateSource(FIX::RateSource *arg1) {
    delete arg1;
}

swig_class cAllocPositionEffect;

SWIGINTERN VALUE
_wrap_new_AllocPositionEffect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocPositionEffect *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocPositionEffect";
  
  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 ;
  FIX::AllocPositionEffect *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocPositionEffect";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocPositionEffect'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocPositionEffect(FIX::AllocPositionEffect *arg1) {
    delete arg1;
}

swig_class cPartyIDSource;

SWIGINTERN VALUE
_wrap_new_PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyIDSource";
  
  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 ;
  FIX::PartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyIDSource(FIX::PartyIDSource *arg1) {
    delete arg1;
}

swig_class cEncodedUnderlyingIssuer;

SWIGINTERN VALUE
_wrap_new_EncodedUnderlyingIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedUnderlyingIssuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuer";
  
  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 ;
  FIX::EncodedUnderlyingIssuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedUnderlyingIssuer";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedUnderlyingIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedUnderlyingIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedUnderlyingIssuer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedUnderlyingIssuer(FIX::EncodedUnderlyingIssuer *arg1) {
    delete arg1;
}

swig_class cNoRequestedPartyRoles;

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


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

SWIGINTERN VALUE
_wrap_new_NoRequestedPartyRoles__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRequestedPartyRoles *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRequestedPartyRoles";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRequestedPartyRoles" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRequestedPartyRoles" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRequestedPartyRoles *)new FIX::NoRequestedPartyRoles((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRequestedPartyRoles(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRequestedPartyRoles__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_NoRequestedPartyRoles__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRequestedPartyRoles'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRequestedPartyRoles(FIX::NoRequestedPartyRoles *arg1) {
    delete arg1;
}

swig_class cEncryptedPassword;

SWIGINTERN VALUE
_wrap_new_EncryptedPassword__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncryptedPassword *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPassword";
  
  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 ;
  FIX::EncryptedPassword *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPassword";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncryptedPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncryptedPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncryptedPassword'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedPassword(FIX::EncryptedPassword *arg1) {
    delete arg1;
}

swig_class cTriggerNewQty;

SWIGINTERN VALUE
_wrap_new_TriggerNewQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerNewQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewQty";
  
  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 ;
  FIX::TriggerNewQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerNewQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::TriggerNewQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerNewQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerNewQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerNewQty(FIX::TriggerNewQty *arg1) {
    delete arg1;
}

swig_class cLegLastForwardPoints;

SWIGINTERN VALUE
_wrap_new_LegLastForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegLastForwardPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastForwardPoints";
  
  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 ;
  FIX::LegLastForwardPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLastForwardPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegLastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegLastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegLastForwardPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLastForwardPoints(FIX::LegLastForwardPoints *arg1) {
    delete arg1;
}

swig_class cTotNumTradeReports;

SWIGINTERN VALUE
_wrap_new_TotNumTradeReports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNumTradeReports *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumTradeReports";
  
  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 ;
  FIX::TotNumTradeReports *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNumTradeReports";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNumTradeReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNumTradeReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNumTradeReports'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNumTradeReports(FIX::TotNumTradeReports *arg1) {
    delete arg1;
}

swig_class cRefApplVerID;

SWIGINTERN VALUE
_wrap_new_RefApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefApplVerID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplVerID";
  
  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 ;
  FIX::RefApplVerID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplVerID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefApplVerID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplVerID(FIX::RefApplVerID *arg1) {
    delete arg1;
}

swig_class cLastSpotRate;

SWIGINTERN VALUE
_wrap_new_LastSpotRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastSpotRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastSpotRate";
  
  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 ;
  FIX::LastSpotRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastSpotRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastSpotRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastSpotRate(FIX::LastSpotRate *arg1) {
    delete arg1;
}

swig_class cPrice;

SWIGINTERN VALUE
_wrap_new_Price__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Price *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Price";
  
  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 ;
  FIX::Price *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Price";
  
  if ((argc < 1) || (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), "in method '" "FIX::Price" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Price" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Price'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Price(FIX::Price *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityIDSource";
  
  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 ;
  FIX::UnderlyingSecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityIDSource(FIX::UnderlyingSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cTotNoSecurityTypes;

SWIGINTERN VALUE
_wrap_new_TotNoSecurityTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoSecurityTypes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoSecurityTypes";
  
  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 ;
  FIX::TotNoSecurityTypes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoSecurityTypes";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoSecurityTypes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoSecurityTypes(FIX::TotNoSecurityTypes *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskInstrumentMultiplier;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskInstrumentMultiplier__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::FLOAT *arg1 = 0 ;
  FIX::RelationshipRiskInstrumentMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskInstrumentMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskInstrumentMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  result = (FIX::RelationshipRiskInstrumentMultiplier *)new FIX::RelationshipRiskInstrumentMultiplier((FIX::FLOAT const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskInstrumentMultiplier(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskInstrumentMultiplier__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_RelationshipRiskInstrumentMultiplier__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskInstrumentMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskInstrumentMultiplier(FIX::RelationshipRiskInstrumentMultiplier *arg1) {
    delete arg1;
}

swig_class cNoRiskInstruments;

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


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

SWIGINTERN VALUE
_wrap_new_NoRiskInstruments__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskInstruments *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRiskInstruments";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRiskInstruments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRiskInstruments *)new FIX::NoRiskInstruments((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRiskInstruments(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRiskInstruments__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_NoRiskInstruments__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRiskInstruments'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRiskInstruments(FIX::NoRiskInstruments *arg1) {
    delete arg1;
}

swig_class cReportedPx;

SWIGINTERN VALUE
_wrap_new_ReportedPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ReportedPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportedPx";
  
  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 ;
  FIX::ReportedPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportedPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::ReportedPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ReportedPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ReportedPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ReportedPx(FIX::ReportedPx *arg1) {
    delete arg1;
}

swig_class cLegSymbol;

SWIGINTERN VALUE
_wrap_new_LegSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSymbol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSymbol";
  
  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 ;
  FIX::LegSymbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSymbol";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSymbol(FIX::LegSymbol *arg1) {
    delete arg1;
}

swig_class cLegIssuer;

SWIGINTERN VALUE
_wrap_new_LegIssuer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegIssuer *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIssuer";
  
  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 ;
  FIX::LegIssuer *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIssuer";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegIssuer'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIssuer(FIX::LegIssuer *arg1) {
    delete arg1;
}

swig_class cRegistDetls;

SWIGINTERN VALUE
_wrap_new_RegistDetls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RegistDetls *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistDetls";
  
  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 ;
  FIX::RegistDetls *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RegistDetls";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RegistDetls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RegistDetls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RegistDetls'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RegistDetls(FIX::RegistDetls *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecurityID;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecurityID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityID";
  
  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 ;
  FIX::UnderlyingLegSecurityID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityID(FIX::UnderlyingLegSecurityID *arg1) {
    delete arg1;
}

swig_class cMinLotSize;

SWIGINTERN VALUE
_wrap_new_MinLotSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MinLotSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinLotSize";
  
  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 ;
  FIX::MinLotSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinLotSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::MinLotSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MinLotSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MinLotSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MinLotSize(FIX::MinLotSize *arg1) {
    delete arg1;
}

swig_class cNumTickets;

SWIGINTERN VALUE
_wrap_new_NumTickets__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NumTickets *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumTickets";
  
  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 ;
  FIX::NumTickets *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumTickets";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NumTickets" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NumTickets" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NumTickets'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NumTickets(FIX::NumTickets *arg1) {
    delete arg1;
}

swig_class cLegLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_LegLocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegLocaleOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLocaleOfIssue";
  
  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 ;
  FIX::LegLocaleOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegLocaleOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegLocaleOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegLocaleOfIssue(FIX::LegLocaleOfIssue *arg1) {
    delete arg1;
}

swig_class cExchangeForPhysical;

SWIGINTERN VALUE
_wrap_new_ExchangeForPhysical__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExchangeForPhysical *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeForPhysical";
  
  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 ;
  FIX::ExchangeForPhysical *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExchangeForPhysical";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExchangeForPhysical" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExchangeForPhysical" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExchangeForPhysical'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExchangeForPhysical(FIX::ExchangeForPhysical *arg1) {
    delete arg1;
}

swig_class cSecurityTradingEvent;

SWIGINTERN VALUE
_wrap_new_SecurityTradingEvent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityTradingEvent *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingEvent";
  
  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 ;
  FIX::SecurityTradingEvent *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingEvent";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityTradingEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityTradingEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityTradingEvent'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityTradingEvent(FIX::SecurityTradingEvent *arg1) {
    delete arg1;
}

swig_class cMinPriceIncrementAmount;

SWIGINTERN VALUE
_wrap_new_MinPriceIncrementAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MinPriceIncrementAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrementAmount";
  
  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 ;
  FIX::MinPriceIncrementAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MinPriceIncrementAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::MinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MinPriceIncrementAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MinPriceIncrementAmount(FIX::MinPriceIncrementAmount *arg1) {
    delete arg1;
}

swig_class cUnderlyingPayAmount;

SWIGINTERN VALUE
_wrap_new_UnderlyingPayAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingPayAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPayAmount";
  
  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 ;
  FIX::UnderlyingPayAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPayAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingPayAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPayAmount(FIX::UnderlyingPayAmount *arg1) {
    delete arg1;
}

swig_class cSettlPartySubID;

SWIGINTERN VALUE
_wrap_new_SettlPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlPartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubID";
  
  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 ;
  FIX::SettlPartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartySubID(FIX::SettlPartySubID *arg1) {
    delete arg1;
}

swig_class cAllocNetMoney;

SWIGINTERN VALUE
_wrap_new_AllocNetMoney__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocNetMoney *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocNetMoney";
  
  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 ;
  FIX::AllocNetMoney *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocNetMoney";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocNetMoney'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocNetMoney(FIX::AllocNetMoney *arg1) {
    delete arg1;
}

swig_class cUnderlyingMaturityDay;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityDay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingMaturityDay *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDay";
  
  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 ;
  FIX::UnderlyingMaturityDay *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDay";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingMaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingMaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingMaturityDay'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityDay(FIX::UnderlyingMaturityDay *arg1) {
    delete arg1;
}

swig_class cNetworkResponseID;

SWIGINTERN VALUE
_wrap_new_NetworkResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NetworkResponseID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkResponseID";
  
  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 ;
  FIX::NetworkResponseID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkResponseID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetworkResponseID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkResponseID(FIX::NetworkResponseID *arg1) {
    delete arg1;
}

swig_class cNumBidders;

SWIGINTERN VALUE
_wrap_new_NumBidders__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NumBidders *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumBidders";
  
  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 ;
  FIX::NumBidders *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NumBidders";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NumBidders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NumBidders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NumBidders'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NumBidders(FIX::NumBidders *arg1) {
    delete arg1;
}

swig_class cAllocAcctIDSource;

SWIGINTERN VALUE
_wrap_new_AllocAcctIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocAcctIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAcctIDSource";
  
  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 ;
  FIX::AllocAcctIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAcctIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocAcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocAcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocAcctIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAcctIDSource(FIX::AllocAcctIDSource *arg1) {
    delete arg1;
}

swig_class cAllocAvgPx;

SWIGINTERN VALUE
_wrap_new_AllocAvgPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocAvgPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAvgPx";
  
  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 ;
  FIX::AllocAvgPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocAvgPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocAvgPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocAvgPx(FIX::AllocAvgPx *arg1) {
    delete arg1;
}

swig_class cSecuritySettlAgentCode;

SWIGINTERN VALUE
_wrap_new_SecuritySettlAgentCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecuritySettlAgentCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentCode";
  
  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 ;
  FIX::SecuritySettlAgentCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecuritySettlAgentCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecuritySettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecuritySettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecuritySettlAgentCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecuritySettlAgentCode(FIX::SecuritySettlAgentCode *arg1) {
    delete arg1;
}

swig_class cNoDistribInsts;

SWIGINTERN VALUE
_wrap_new_NoDistribInsts__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDistribInsts *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDistribInsts";
  
  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 ;
  FIX::NoDistribInsts *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDistribInsts";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoDistribInsts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDistribInsts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDistribInsts'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDistribInsts(FIX::NoDistribInsts *arg1) {
    delete arg1;
}

swig_class cCustDirectedOrder;

SWIGINTERN VALUE
_wrap_new_CustDirectedOrder__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CustDirectedOrder *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustDirectedOrder";
  
  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 ;
  FIX::CustDirectedOrder *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CustDirectedOrder";
  
  if ((argc < 1) || (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), "in method '" "FIX::CustDirectedOrder" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CustDirectedOrder" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CustDirectedOrder'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CustDirectedOrder(FIX::CustDirectedOrder *arg1) {
    delete arg1;
}

swig_class cFairValue;

SWIGINTERN VALUE
_wrap_new_FairValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FairValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FairValue";
  
  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 ;
  FIX::FairValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FairValue";
  
  if ((argc < 1) || (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), "in method '" "FIX::FairValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FairValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FairValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FairValue(FIX::FairValue *arg1) {
    delete arg1;
}

swig_class cNoStrikes;

SWIGINTERN VALUE
_wrap_new_NoStrikes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoStrikes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrikes";
  
  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 ;
  FIX::NoStrikes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrikes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoStrikes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoStrikes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoStrikes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStrikes(FIX::NoStrikes *arg1) {
    delete arg1;
}

swig_class cEncodedSecurityListDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityListDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedSecurityListDescLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDescLen";
  
  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 ;
  FIX::EncodedSecurityListDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityListDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSecurityListDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSecurityListDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSecurityListDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityListDescLen(FIX::EncodedSecurityListDescLen *arg1) {
    delete arg1;
}

swig_class cLegExerciseStyle;

SWIGINTERN VALUE
_wrap_new_LegExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegExerciseStyle *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegExerciseStyle";
  
  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 ;
  FIX::LegExerciseStyle *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegExerciseStyle";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegExerciseStyle'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegExerciseStyle(FIX::LegExerciseStyle *arg1) {
    delete arg1;
}

swig_class cDerivativeSymbolSfx;

SWIGINTERN VALUE
_wrap_new_DerivativeSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSymbolSfx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbolSfx";
  
  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 ;
  FIX::DerivativeSymbolSfx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbolSfx";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSymbolSfx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSymbolSfx(FIX::DerivativeSymbolSfx *arg1) {
    delete arg1;
}

swig_class cNestedInstrAttribType;

SWIGINTERN VALUE
_wrap_new_NestedInstrAttribType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NestedInstrAttribType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribType";
  
  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 ;
  FIX::NestedInstrAttribType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NestedInstrAttribType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NestedInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NestedInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NestedInstrAttribType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NestedInstrAttribType(FIX::NestedInstrAttribType *arg1) {
    delete arg1;
}

swig_class cContraTrader;

SWIGINTERN VALUE
_wrap_new_ContraTrader__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContraTrader *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTrader";
  
  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 ;
  FIX::ContraTrader *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraTrader";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ContraTrader" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContraTrader" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContraTrader'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraTrader(FIX::ContraTrader *arg1) {
    delete arg1;
}

swig_class cRiskInstrumentSettlType;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskInstrumentSettlType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskInstrumentSettlType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskInstrumentSettlType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskInstrumentSettlType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskInstrumentSettlType(FIX::RiskInstrumentSettlType *arg1) {
    delete arg1;
}

swig_class cMDSecSize;

SWIGINTERN VALUE
_wrap_new_MDSecSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDSecSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSecSize";
  
  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 ;
  FIX::MDSecSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDSecSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDSecSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDSecSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDSecSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDSecSize(FIX::MDSecSize *arg1) {
    delete arg1;
}

swig_class cNoOfSecSizes;

SWIGINTERN VALUE
_wrap_new_NoOfSecSizes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoOfSecSizes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOfSecSizes";
  
  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 ;
  FIX::NoOfSecSizes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOfSecSizes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoOfSecSizes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoOfSecSizes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoOfSecSizes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOfSecSizes(FIX::NoOfSecSizes *arg1) {
    delete arg1;
}

swig_class cCollAction;

SWIGINTERN VALUE
_wrap_new_CollAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAction";
  
  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 ;
  FIX::CollAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAction";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAction(FIX::CollAction *arg1) {
    delete arg1;
}

swig_class cUnderlyingLastQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingLastQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLastQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastQty";
  
  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 ;
  FIX::UnderlyingLastQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLastQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLastQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLastQty(FIX::UnderlyingLastQty *arg1) {
    delete arg1;
}

swig_class cPossDupFlag;

SWIGINTERN VALUE
_wrap_new_PossDupFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PossDupFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PossDupFlag";
  
  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 ;
  FIX::PossDupFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PossDupFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::PossDupFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PossDupFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PossDupFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PossDupFlag(FIX::PossDupFlag *arg1) {
    delete arg1;
}

swig_class cListStatusType;

SWIGINTERN VALUE
_wrap_new_ListStatusType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListStatusType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListStatusType";
  
  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 ;
  FIX::ListStatusType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListStatusType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListStatusType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListStatusType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListStatusType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListStatusType(FIX::ListStatusType *arg1) {
    delete arg1;
}

swig_class cSideFillStationCd;

SWIGINTERN VALUE
_wrap_new_SideFillStationCd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SideFillStationCd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideFillStationCd";
  
  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 ;
  FIX::SideFillStationCd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SideFillStationCd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SideFillStationCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SideFillStationCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SideFillStationCd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SideFillStationCd(FIX::SideFillStationCd *arg1) {
    delete arg1;
}

swig_class cStatusText;

SWIGINTERN VALUE
_wrap_new_StatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StatusText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatusText";
  
  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 ;
  FIX::StatusText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StatusText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StatusText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StatusText(FIX::StatusText *arg1) {
    delete arg1;
}

swig_class cBasisFeatureDate;

SWIGINTERN VALUE
_wrap_new_BasisFeatureDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BasisFeatureDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisFeatureDate";
  
  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 ;
  FIX::BasisFeatureDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BasisFeatureDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::BasisFeatureDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BasisFeatureDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BasisFeatureDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BasisFeatureDate(FIX::BasisFeatureDate *arg1) {
    delete arg1;
}

swig_class cXmlDataLen;

SWIGINTERN VALUE
_wrap_new_XmlDataLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::XmlDataLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::XmlDataLen";
  
  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 ;
  FIX::XmlDataLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::XmlDataLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::XmlDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::XmlDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_XmlDataLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_XmlDataLen(FIX::XmlDataLen *arg1) {
    delete arg1;
}

swig_class cUnderlyingMaturityDate;

SWIGINTERN VALUE
_wrap_new_UnderlyingMaturityDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingMaturityDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDate";
  
  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 ;
  FIX::UnderlyingMaturityDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingMaturityDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingMaturityDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingMaturityDate(FIX::UnderlyingMaturityDate *arg1) {
    delete arg1;
}

swig_class cGapFillFlag;

SWIGINTERN VALUE
_wrap_new_GapFillFlag__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::GapFillFlag *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GapFillFlag";
  
  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 ;
  FIX::GapFillFlag *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::GapFillFlag";
  
  if ((argc < 1) || (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), "in method '" "FIX::GapFillFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::GapFillFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_GapFillFlag'");
  return Qnil;
}


SWIGINTERN void
free_FIX_GapFillFlag(FIX::GapFillFlag *arg1) {
    delete arg1;
}

swig_class cRefApplExtID;

SWIGINTERN VALUE
_wrap_new_RefApplExtID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefApplExtID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplExtID";
  
  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 ;
  FIX::RefApplExtID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplExtID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefApplExtID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplExtID(FIX::RefApplExtID *arg1) {
    delete arg1;
}

swig_class cRefApplID;

SWIGINTERN VALUE
_wrap_new_RefApplID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefApplID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplID";
  
  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 ;
  FIX::RefApplID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefApplID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefApplID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefApplID(FIX::RefApplID *arg1) {
    delete arg1;
}

swig_class cNoTradingSessionRules;

SWIGINTERN VALUE
_wrap_new_NoTradingSessionRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTradingSessionRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessionRules";
  
  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 ;
  FIX::NoTradingSessionRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTradingSessionRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTradingSessionRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTradingSessionRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTradingSessionRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTradingSessionRules(FIX::NoTradingSessionRules *arg1) {
    delete arg1;
}

swig_class cSwapPoints;

SWIGINTERN VALUE
_wrap_new_SwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SwapPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SwapPoints";
  
  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 ;
  FIX::SwapPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SwapPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::SwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SwapPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SwapPoints(FIX::SwapPoints *arg1) {
    delete arg1;
}

swig_class cTargetStrategyParameters;

SWIGINTERN VALUE
_wrap_new_TargetStrategyParameters__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetStrategyParameters *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyParameters";
  
  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 ;
  FIX::TargetStrategyParameters *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetStrategyParameters";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TargetStrategyParameters" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetStrategyParameters" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetStrategyParameters'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetStrategyParameters(FIX::TargetStrategyParameters *arg1) {
    delete arg1;
}

swig_class cLastForwardPoints;

SWIGINTERN VALUE
_wrap_new_LastForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastForwardPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints";
  
  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 ;
  FIX::LastForwardPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastForwardPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastForwardPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastForwardPoints(FIX::LastForwardPoints *arg1) {
    delete arg1;
}

swig_class cYieldRedemptionDate;

SWIGINTERN VALUE
_wrap_new_YieldRedemptionDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::YieldRedemptionDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionDate";
  
  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 ;
  FIX::YieldRedemptionDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::YieldRedemptionDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::YieldRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::YieldRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_YieldRedemptionDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_YieldRedemptionDate(FIX::YieldRedemptionDate *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecurityID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityID(FIX::RelationshipRiskSecurityID *arg1) {
    delete arg1;
}

swig_class cNoSettlDetails;

SWIGINTERN VALUE
_wrap_new_NoSettlDetails__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSettlDetails *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlDetails";
  
  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 ;
  FIX::NoSettlDetails *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSettlDetails";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSettlDetails" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSettlDetails" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSettlDetails'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSettlDetails(FIX::NoSettlDetails *arg1) {
    delete arg1;
}

swig_class cTradeHandlingInstr;

SWIGINTERN VALUE
_wrap_new_TradeHandlingInstr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeHandlingInstr *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeHandlingInstr";
  
  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 ;
  FIX::TradeHandlingInstr *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeHandlingInstr";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeHandlingInstr'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeHandlingInstr(FIX::TradeHandlingInstr *arg1) {
    delete arg1;
}

swig_class cCashSettlAgentCode;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashSettlAgentCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentCode";
  
  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 ;
  FIX::CashSettlAgentCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashSettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashSettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashSettlAgentCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentCode(FIX::CashSettlAgentCode *arg1) {
    delete arg1;
}

swig_class cLegPriceType;

SWIGINTERN VALUE
_wrap_new_LegPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceType";
  
  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 ;
  FIX::LegPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegPriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegPriceType(FIX::LegPriceType *arg1) {
    delete arg1;
}

swig_class cEncodedListExecInstLen;

SWIGINTERN VALUE
_wrap_new_EncodedListExecInstLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedListExecInstLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInstLen";
  
  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 ;
  FIX::EncodedListExecInstLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListExecInstLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedListExecInstLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedListExecInstLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedListExecInstLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListExecInstLen(FIX::EncodedListExecInstLen *arg1) {
    delete arg1;
}

swig_class cTradSesMethod;

SWIGINTERN VALUE
_wrap_new_TradSesMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradSesMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesMethod";
  
  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 ;
  FIX::TradSesMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradSesMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradSesMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradSesMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradSesMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradSesMethod(FIX::TradSesMethod *arg1) {
    delete arg1;
}

swig_class cRiskLimitCurrency;

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


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

SWIGINTERN VALUE
_wrap_new_RiskLimitCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  FIX::RiskLimitCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskLimitCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::RiskLimitCurrency *)new FIX::RiskLimitCurrency((FIX::CURRENCY const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskLimitCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskLimitCurrency__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_RiskLimitCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskLimitCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskLimitCurrency(FIX::RiskLimitCurrency *arg1) {
    delete arg1;
}

swig_class cPartyDetailsListRequestID;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyDetailsListRequestID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyDetailsListRequestID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyDetailsListRequestID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyDetailsListRequestID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyDetailsListRequestID(FIX::PartyDetailsListRequestID *arg1) {
    delete arg1;
}

swig_class cAgreementID;

SWIGINTERN VALUE
_wrap_new_AgreementID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AgreementID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementID";
  
  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 ;
  FIX::AgreementID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AgreementID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AgreementID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AgreementID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AgreementID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AgreementID(FIX::AgreementID *arg1) {
    delete arg1;
}

swig_class cCashDistribCurr;

SWIGINTERN VALUE
_wrap_new_CashDistribCurr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashDistribCurr *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribCurr";
  
  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 ;
  FIX::CashDistribCurr *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashDistribCurr";
  
  if ((argc < 1) || (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), "in method '" "FIX::CashDistribCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashDistribCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashDistribCurr'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashDistribCurr(FIX::CashDistribCurr *arg1) {
    delete arg1;
}

swig_class cBidPx;

SWIGINTERN VALUE
_wrap_new_BidPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidPx";
  
  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 ;
  FIX::BidPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidPx(FIX::BidPx *arg1) {
    delete arg1;
}

swig_class cTradeType;

SWIGINTERN VALUE
_wrap_new_TradeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeType";
  
  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 ;
  FIX::TradeType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeType";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeType(FIX::TradeType *arg1) {
    delete arg1;
}

swig_class cEncodedSecurityDescLen;

SWIGINTERN VALUE
_wrap_new_EncodedSecurityDescLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedSecurityDescLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDescLen";
  
  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 ;
  FIX::EncodedSecurityDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedSecurityDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedSecurityDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedSecurityDescLen(FIX::EncodedSecurityDescLen *arg1) {
    delete arg1;
}

swig_class cComplexEventCondition;

SWIGINTERN VALUE
_wrap_new_ComplexEventCondition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventCondition *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventCondition";
  
  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 ;
  FIX::ComplexEventCondition *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventCondition";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ComplexEventCondition" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventCondition" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventCondition'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventCondition(FIX::ComplexEventCondition *arg1) {
    delete arg1;
}

swig_class cEncryptedPasswordMethod;

SWIGINTERN VALUE
_wrap_new_EncryptedPasswordMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncryptedPasswordMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordMethod";
  
  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 ;
  FIX::EncryptedPasswordMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncryptedPasswordMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::EncryptedPasswordMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncryptedPasswordMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncryptedPasswordMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncryptedPasswordMethod(FIX::EncryptedPasswordMethod *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityAltID;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltID";
  
  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 ;
  FIX::DerivativeSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityAltID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityAltID(FIX::DerivativeSecurityAltID *arg1) {
    delete arg1;
}

swig_class cTotNoAccQuotes;

SWIGINTERN VALUE
_wrap_new_TotNoAccQuotes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoAccQuotes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoAccQuotes";
  
  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 ;
  FIX::TotNoAccQuotes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoAccQuotes";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoAccQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoAccQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoAccQuotes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoAccQuotes(FIX::TotNoAccQuotes *arg1) {
    delete arg1;
}

swig_class cTimeBracket;

SWIGINTERN VALUE
_wrap_new_TimeBracket__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TimeBracket *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeBracket";
  
  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 ;
  FIX::TimeBracket *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeBracket";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TimeBracket" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TimeBracket" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TimeBracket'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeBracket(FIX::TimeBracket *arg1) {
    delete arg1;
}

swig_class cNoAllocs;

SWIGINTERN VALUE
_wrap_new_NoAllocs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoAllocs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAllocs";
  
  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 ;
  FIX::NoAllocs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoAllocs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoAllocs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoAllocs(FIX::NoAllocs *arg1) {
    delete arg1;
}

swig_class cUnderlyingProduct;

SWIGINTERN VALUE
_wrap_new_UnderlyingProduct__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingProduct *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingProduct";
  
  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 ;
  FIX::UnderlyingProduct *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingProduct";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingProduct'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingProduct(FIX::UnderlyingProduct *arg1) {
    delete arg1;
}

swig_class cBenchmarkCurveName;

SWIGINTERN VALUE
_wrap_new_BenchmarkCurveName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BenchmarkCurveName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveName";
  
  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 ;
  FIX::BenchmarkCurveName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkCurveName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BenchmarkCurveName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkCurveName(FIX::BenchmarkCurveName *arg1) {
    delete arg1;
}

swig_class cUnderlyingSymbolSfx;

SWIGINTERN VALUE
_wrap_new_UnderlyingSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSymbolSfx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbolSfx";
  
  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 ;
  FIX::UnderlyingSymbolSfx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSymbolSfx";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSymbolSfx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSymbolSfx(FIX::UnderlyingSymbolSfx *arg1) {
    delete arg1;
}

swig_class cStrikePriceBoundaryPrecision;

SWIGINTERN VALUE
_wrap_new_StrikePriceBoundaryPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrikePriceBoundaryPrecision *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryPrecision";
  
  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 ;
  FIX::StrikePriceBoundaryPrecision *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrikePriceBoundaryPrecision";
  
  if ((argc < 1) || (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), "in method '" "FIX::StrikePriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrikePriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrikePriceBoundaryPrecision'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrikePriceBoundaryPrecision(FIX::StrikePriceBoundaryPrecision *arg1) {
    delete arg1;
}

swig_class cQuoteSetID;

SWIGINTERN VALUE
_wrap_new_QuoteSetID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteSetID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetID";
  
  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 ;
  FIX::QuoteSetID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteSetID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteSetID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteSetID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteSetID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteSetID(FIX::QuoteSetID *arg1) {
    delete arg1;
}

swig_class cCashMargin;

SWIGINTERN VALUE
_wrap_new_CashMargin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashMargin *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashMargin";
  
  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 ;
  FIX::CashMargin *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashMargin";
  
  if ((argc < 1) || (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), "in method '" "FIX::CashMargin" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashMargin" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashMargin'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashMargin(FIX::CashMargin *arg1) {
    delete arg1;
}

swig_class cSettlObligTransType;

SWIGINTERN VALUE
_wrap_new_SettlObligTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlObligTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligTransType";
  
  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 ;
  FIX::SettlObligTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlObligTransType";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlObligTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlObligTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlObligTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlObligTransType(FIX::SettlObligTransType *arg1) {
    delete arg1;
}

swig_class cLegNumber;

SWIGINTERN VALUE
_wrap_new_LegNumber__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegNumber *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegNumber";
  
  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 ;
  FIX::LegNumber *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegNumber";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegNumber" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegNumber" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegNumber'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegNumber(FIX::LegNumber *arg1) {
    delete arg1;
}

swig_class cDeskOrderHandlingInst;

SWIGINTERN VALUE
_wrap_new_DeskOrderHandlingInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeskOrderHandlingInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskOrderHandlingInst";
  
  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 ;
  FIX::DeskOrderHandlingInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskOrderHandlingInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::DeskOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeskOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeskOrderHandlingInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskOrderHandlingInst(FIX::DeskOrderHandlingInst *arg1) {
    delete arg1;
}

swig_class cSettlPartyIDSource;

SWIGINTERN VALUE
_wrap_new_SettlPartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlPartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyIDSource";
  
  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 ;
  FIX::SettlPartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlPartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlPartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlPartyIDSource(FIX::SettlPartyIDSource *arg1) {
    delete arg1;
}

swig_class cPriorSettlPrice;

SWIGINTERN VALUE
_wrap_new_PriorSettlPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriorSettlPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorSettlPrice";
  
  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 ;
  FIX::PriorSettlPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorSettlPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::PriorSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriorSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriorSettlPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriorSettlPrice(FIX::PriorSettlPrice *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSecurityType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSecurityType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSecurityType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSecurityType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSecurityType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSecurityType(FIX::RelationshipRiskSecurityType *arg1) {
    delete arg1;
}

swig_class cNotAffOrigClOrdID;

SWIGINTERN VALUE
_wrap_new_NotAffOrigClOrdID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NotAffOrigClOrdID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotAffOrigClOrdID";
  
  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 ;
  FIX::NotAffOrigClOrdID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NotAffOrigClOrdID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NotAffOrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NotAffOrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NotAffOrigClOrdID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NotAffOrigClOrdID(FIX::NotAffOrigClOrdID *arg1) {
    delete arg1;
}

swig_class cTradingSessionDesc;

SWIGINTERN VALUE
_wrap_new_TradingSessionDesc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradingSessionDesc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionDesc";
  
  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 ;
  FIX::TradingSessionDesc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradingSessionDesc";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TradingSessionDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradingSessionDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradingSessionDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradingSessionDesc(FIX::TradingSessionDesc *arg1) {
    delete arg1;
}

swig_class cDerivativeFloorPrice;

SWIGINTERN VALUE
_wrap_new_DerivativeFloorPrice__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeFloorPrice *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFloorPrice";
  
  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 ;
  FIX::DerivativeFloorPrice *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeFloorPrice";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeFloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeFloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeFloorPrice'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeFloorPrice(FIX::DerivativeFloorPrice *arg1) {
    delete arg1;
}

swig_class cDerivativeSymbol;

SWIGINTERN VALUE
_wrap_new_DerivativeSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSymbol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbol";
  
  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 ;
  FIX::DerivativeSymbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSymbol";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSymbol(FIX::DerivativeSymbol *arg1) {
    delete arg1;
}

swig_class cRiskFreeRate;

SWIGINTERN VALUE
_wrap_new_RiskFreeRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RiskFreeRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskFreeRate";
  
  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 ;
  FIX::RiskFreeRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskFreeRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskFreeRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskFreeRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskFreeRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskFreeRate(FIX::RiskFreeRate *arg1) {
    delete arg1;
}

swig_class cPosTransType;

SWIGINTERN VALUE
_wrap_new_PosTransType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosTransType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosTransType";
  
  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 ;
  FIX::PosTransType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosTransType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosTransType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosTransType(FIX::PosTransType *arg1) {
    delete arg1;
}

swig_class cMsgSeqNum;

SWIGINTERN VALUE
_wrap_new_MsgSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MsgSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgSeqNum";
  
  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 ;
  FIX::MsgSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MsgSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::MsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MsgSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MsgSeqNum(FIX::MsgSeqNum *arg1) {
    delete arg1;
}

swig_class cSignature;

SWIGINTERN VALUE
_wrap_new_Signature__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Signature *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Signature";
  
  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 ;
  FIX::Signature *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Signature";
  
  if ((argc < 1) || (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), "in method '" "FIX::Signature" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Signature" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Signature'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Signature(FIX::Signature *arg1) {
    delete arg1;
}

swig_class cSeniority;

SWIGINTERN VALUE
_wrap_new_Seniority__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Seniority *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Seniority";
  
  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 ;
  FIX::Seniority *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Seniority";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Seniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Seniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Seniority'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Seniority(FIX::Seniority *arg1) {
    delete arg1;
}

swig_class cNoRateSources;

SWIGINTERN VALUE
_wrap_new_NoRateSources__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoRateSources *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRateSources";
  
  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 ;
  FIX::NoRateSources *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRateSources";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRateSources" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRateSources" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRateSources'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRateSources(FIX::NoRateSources *arg1) {
    delete arg1;
}

swig_class cPriceUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_PriceUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriceUnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasureQty";
  
  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 ;
  FIX::PriceUnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriceUnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::PriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriceUnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriceUnitOfMeasureQty(FIX::PriceUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cCollAsgnRefID;

SWIGINTERN VALUE
_wrap_new_CollAsgnRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollAsgnRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRefID";
  
  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 ;
  FIX::CollAsgnRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollAsgnRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollAsgnRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollAsgnRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollAsgnRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollAsgnRefID(FIX::CollAsgnRefID *arg1) {
    delete arg1;
}

swig_class cBuyVolume;

SWIGINTERN VALUE
_wrap_new_BuyVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BuyVolume *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BuyVolume";
  
  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 ;
  FIX::BuyVolume *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BuyVolume";
  
  if ((argc < 1) || (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), "in method '" "FIX::BuyVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BuyVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BuyVolume'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BuyVolume(FIX::BuyVolume *arg1) {
    delete arg1;
}

swig_class cSettlCurrFxRateCalc;

SWIGINTERN VALUE
_wrap_new_SettlCurrFxRateCalc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlCurrFxRateCalc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRateCalc";
  
  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 ;
  FIX::SettlCurrFxRateCalc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrFxRateCalc";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlCurrFxRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlCurrFxRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlCurrFxRateCalc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrFxRateCalc(FIX::SettlCurrFxRateCalc *arg1) {
    delete arg1;
}

swig_class cPosMaintStatus;

SWIGINTERN VALUE
_wrap_new_PosMaintStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosMaintStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintStatus";
  
  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 ;
  FIX::PosMaintStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosMaintStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosMaintStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosMaintStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintStatus(FIX::PosMaintStatus *arg1) {
    delete arg1;
}

swig_class cPriorSpreadIndicator;

SWIGINTERN VALUE
_wrap_new_PriorSpreadIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriorSpreadIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorSpreadIndicator";
  
  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 ;
  FIX::PriorSpreadIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorSpreadIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::PriorSpreadIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriorSpreadIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriorSpreadIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriorSpreadIndicator(FIX::PriorSpreadIndicator *arg1) {
    delete arg1;
}

swig_class cBenchmark;

SWIGINTERN VALUE
_wrap_new_Benchmark__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Benchmark *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Benchmark";
  
  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 ;
  FIX::Benchmark *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Benchmark";
  
  if ((argc < 1) || (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), "in method '" "FIX::Benchmark" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Benchmark" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Benchmark'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Benchmark(FIX::Benchmark *arg1) {
    delete arg1;
}

swig_class cMaturityMonthYearFormat;

SWIGINTERN VALUE
_wrap_new_MaturityMonthYearFormat__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityMonthYearFormat *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearFormat";
  
  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 ;
  FIX::MaturityMonthYearFormat *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityMonthYearFormat";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::MaturityMonthYearFormat" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityMonthYearFormat" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityMonthYearFormat'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityMonthYearFormat(FIX::MaturityMonthYearFormat *arg1) {
    delete arg1;
}

swig_class cUnderlyingTradingSessionID;

SWIGINTERN VALUE
_wrap_new_UnderlyingTradingSessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingTradingSessionID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionID";
  
  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 ;
  FIX::UnderlyingTradingSessionID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTradingSessionID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingTradingSessionID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingTradingSessionID(FIX::UnderlyingTradingSessionID *arg1) {
    delete arg1;
}

swig_class cTotNoRelatedSym;

SWIGINTERN VALUE
_wrap_new_TotNoRelatedSym__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoRelatedSym *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoRelatedSym";
  
  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 ;
  FIX::TotNoRelatedSym *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoRelatedSym";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoRelatedSym" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoRelatedSym" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoRelatedSym'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoRelatedSym(FIX::TotNoRelatedSym *arg1) {
    delete arg1;
}

swig_class cStateOrProvinceOfIssue;

SWIGINTERN VALUE
_wrap_new_StateOrProvinceOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StateOrProvinceOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StateOrProvinceOfIssue";
  
  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 ;
  FIX::StateOrProvinceOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StateOrProvinceOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StateOrProvinceOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StateOrProvinceOfIssue(FIX::StateOrProvinceOfIssue *arg1) {
    delete arg1;
}

swig_class cRelatedPartyAltSubID;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedPartyAltSubID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartyAltSubID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedPartyAltSubID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartyAltSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartyAltSubID(FIX::RelatedPartyAltSubID *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrRegistry;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrRegistry *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrRegistry";
  
  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 ;
  FIX::DerivativeInstrRegistry *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrRegistry";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrRegistry'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrRegistry(FIX::DerivativeInstrRegistry *arg1) {
    delete arg1;
}

swig_class cLegBidForwardPoints;

SWIGINTERN VALUE
_wrap_new_LegBidForwardPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegBidForwardPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBidForwardPoints";
  
  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 ;
  FIX::LegBidForwardPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegBidForwardPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegBidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegBidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegBidForwardPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegBidForwardPoints(FIX::LegBidForwardPoints *arg1) {
    delete arg1;
}

swig_class cManualOrderIndicator;

SWIGINTERN VALUE
_wrap_new_ManualOrderIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ManualOrderIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ManualOrderIndicator";
  
  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 ;
  FIX::ManualOrderIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ManualOrderIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::ManualOrderIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ManualOrderIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ManualOrderIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ManualOrderIndicator(FIX::ManualOrderIndicator *arg1) {
    delete arg1;
}

swig_class cNetMoney;

SWIGINTERN VALUE
_wrap_new_NetMoney__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NetMoney *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetMoney";
  
  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 ;
  FIX::NetMoney *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetMoney";
  
  if ((argc < 1) || (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), "in method '" "FIX::NetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetMoney'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NetMoney(FIX::NetMoney *arg1) {
    delete arg1;
}

swig_class cLegalConfirm;

SWIGINTERN VALUE
_wrap_new_LegalConfirm__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegalConfirm *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegalConfirm";
  
  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 ;
  FIX::LegalConfirm *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegalConfirm";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegalConfirm" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegalConfirm" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegalConfirm'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegalConfirm(FIX::LegalConfirm *arg1) {
    delete arg1;
}

swig_class cCountryOfIssue;

SWIGINTERN VALUE
_wrap_new_CountryOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CountryOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CountryOfIssue";
  
  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 ;
  FIX::CountryOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CountryOfIssue";
  
  if ((argc < 1) || (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), "in method '" "FIX::CountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CountryOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CountryOfIssue(FIX::CountryOfIssue *arg1) {
    delete arg1;
}

swig_class cApplReportType;

SWIGINTERN VALUE
_wrap_new_ApplReportType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplReportType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReportType";
  
  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 ;
  FIX::ApplReportType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReportType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplReportType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReportType(FIX::ApplReportType *arg1) {
    delete arg1;
}

swig_class cRootPartyID;

SWIGINTERN VALUE
_wrap_new_RootPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RootPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyID";
  
  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 ;
  FIX::RootPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RootPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RootPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RootPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RootPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RootPartyID(FIX::RootPartyID *arg1) {
    delete arg1;
}

swig_class cUnderlyingQty;

SWIGINTERN VALUE
_wrap_new_UnderlyingQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingQty";
  
  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 ;
  FIX::UnderlyingQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingQty(FIX::UnderlyingQty *arg1) {
    delete arg1;
}

swig_class cApplQueueDepth;

SWIGINTERN VALUE
_wrap_new_ApplQueueDepth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplQueueDepth *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueDepth";
  
  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 ;
  FIX::ApplQueueDepth *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueDepth";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplQueueDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplQueueDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplQueueDepth'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueDepth(FIX::ApplQueueDepth *arg1) {
    delete arg1;
}

swig_class cStopPx;

SWIGINTERN VALUE
_wrap_new_StopPx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StopPx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StopPx";
  
  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 ;
  FIX::StopPx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StopPx";
  
  if ((argc < 1) || (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), "in method '" "FIX::StopPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StopPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StopPx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StopPx(FIX::StopPx *arg1) {
    delete arg1;
}

swig_class cReportToExch;

SWIGINTERN VALUE
_wrap_new_ReportToExch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ReportToExch *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportToExch";
  
  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 ;
  FIX::ReportToExch *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReportToExch";
  
  if ((argc < 1) || (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), "in method '" "FIX::ReportToExch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ReportToExch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ReportToExch'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ReportToExch(FIX::ReportToExch *arg1) {
    delete arg1;
}

swig_class cContraryInstructionIndicator;

SWIGINTERN VALUE
_wrap_new_ContraryInstructionIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContraryInstructionIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraryInstructionIndicator";
  
  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 ;
  FIX::ContraryInstructionIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContraryInstructionIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::ContraryInstructionIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContraryInstructionIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContraryInstructionIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContraryInstructionIndicator(FIX::ContraryInstructionIndicator *arg1) {
    delete arg1;
}

swig_class cEncodedListStatusTextLen;

SWIGINTERN VALUE
_wrap_new_EncodedListStatusTextLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedListStatusTextLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusTextLen";
  
  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 ;
  FIX::EncodedListStatusTextLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusTextLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedListStatusTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedListStatusTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedListStatusTextLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListStatusTextLen(FIX::EncodedListStatusTextLen *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityXMLSchema;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXMLSchema__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityXMLSchema *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLSchema";
  
  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 ;
  FIX::DerivativeSecurityXMLSchema *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLSchema";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityXMLSchema'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityXMLSchema(FIX::DerivativeSecurityXMLSchema *arg1) {
    delete arg1;
}

swig_class cNoRelatedSym;

SWIGINTERN VALUE
_wrap_new_NoRelatedSym__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoRelatedSym *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedSym";
  
  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 ;
  FIX::NoRelatedSym *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedSym";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelatedSym" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelatedSym" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelatedSym'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedSym(FIX::NoRelatedSym *arg1) {
    delete arg1;
}

swig_class cAllocRejCode;

SWIGINTERN VALUE
_wrap_new_AllocRejCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocRejCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocRejCode";
  
  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 ;
  FIX::AllocRejCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocRejCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocRejCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocRejCode(FIX::AllocRejCode *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecurityAltID;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltID";
  
  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 ;
  FIX::UnderlyingSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityAltID(FIX::UnderlyingSecurityAltID *arg1) {
    delete arg1;
}

swig_class cNoRelationshipRiskSecurityAltID;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelationshipRiskSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelationshipRiskSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelationshipRiskSecurityAltID";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelationshipRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelationshipRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelationshipRiskSecurityAltID *)new FIX::NoRelationshipRiskSecurityAltID((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelationshipRiskSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelationshipRiskSecurityAltID__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_NoRelationshipRiskSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelationshipRiskSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelationshipRiskSecurityAltID(FIX::NoRelationshipRiskSecurityAltID *arg1) {
    delete arg1;
}

swig_class cRefOrdIDReason;

SWIGINTERN VALUE
_wrap_new_RefOrdIDReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefOrdIDReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrdIDReason";
  
  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 ;
  FIX::RefOrdIDReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrdIDReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefOrdIDReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefOrdIDReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefOrdIDReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefOrdIDReason(FIX::RefOrdIDReason *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrumentPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyID";
  
  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 ;
  FIX::DerivativeInstrumentPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrumentPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartyID(FIX::DerivativeInstrumentPartyID *arg1) {
    delete arg1;
}

swig_class cSecurityXMLSchema;

SWIGINTERN VALUE
_wrap_new_SecurityXMLSchema__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityXMLSchema *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLSchema";
  
  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 ;
  FIX::SecurityXMLSchema *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityXMLSchema";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityXMLSchema'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityXMLSchema(FIX::SecurityXMLSchema *arg1) {
    delete arg1;
}

swig_class cRefOrderIDSource;

SWIGINTERN VALUE
_wrap_new_RefOrderIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefOrderIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrderIDSource";
  
  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 ;
  FIX::RefOrderIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefOrderIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::RefOrderIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefOrderIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefOrderIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefOrderIDSource(FIX::RefOrderIDSource *arg1) {
    delete arg1;
}

swig_class cNTPositionLimit;

SWIGINTERN VALUE
_wrap_new_NTPositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NTPositionLimit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NTPositionLimit";
  
  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 ;
  FIX::NTPositionLimit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NTPositionLimit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NTPositionLimit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NTPositionLimit(FIX::NTPositionLimit *arg1) {
    delete arg1;
}

swig_class cEndAccruedInterestAmt;

SWIGINTERN VALUE
_wrap_new_EndAccruedInterestAmt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EndAccruedInterestAmt *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndAccruedInterestAmt";
  
  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 ;
  FIX::EndAccruedInterestAmt *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EndAccruedInterestAmt";
  
  if ((argc < 1) || (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), "in method '" "FIX::EndAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EndAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EndAccruedInterestAmt'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EndAccruedInterestAmt(FIX::EndAccruedInterestAmt *arg1) {
    delete arg1;
}

swig_class cAccruedInterestRate;

SWIGINTERN VALUE
_wrap_new_AccruedInterestRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AccruedInterestRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestRate";
  
  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 ;
  FIX::AccruedInterestRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AccruedInterestRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::AccruedInterestRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AccruedInterestRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AccruedInterestRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AccruedInterestRate(FIX::AccruedInterestRate *arg1) {
    delete arg1;
}

swig_class cLastCapacity;

SWIGINTERN VALUE
_wrap_new_LastCapacity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastCapacity *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastCapacity";
  
  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 ;
  FIX::LastCapacity *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastCapacity";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastCapacity'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastCapacity(FIX::LastCapacity *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskLimitCurrency;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskLimitCurrency__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CURRENCY *arg1 = 0 ;
  FIX::RelationshipRiskLimitCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskLimitCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskLimitCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  result = (FIX::RelationshipRiskLimitCurrency *)new FIX::RelationshipRiskLimitCurrency((FIX::CURRENCY const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskLimitCurrency(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskLimitCurrency__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_RelationshipRiskLimitCurrency__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskLimitCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskLimitCurrency(FIX::RelationshipRiskLimitCurrency *arg1) {
    delete arg1;
}

swig_class cUnderlyingInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingInstrumentPartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubID";
  
  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 ;
  FIX::UnderlyingInstrumentPartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingInstrumentPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartySubID(FIX::UnderlyingInstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class cNoFills;

SWIGINTERN VALUE
_wrap_new_NoFills__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoFills *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoFills";
  
  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 ;
  FIX::NoFills *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoFills";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoFills" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoFills" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoFills'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoFills(FIX::NoFills *arg1) {
    delete arg1;
}

swig_class cNoOrdTypeRules;

SWIGINTERN VALUE
_wrap_new_NoOrdTypeRules__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoOrdTypeRules *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOrdTypeRules";
  
  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 ;
  FIX::NoOrdTypeRules *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoOrdTypeRules";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoOrdTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoOrdTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoOrdTypeRules'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoOrdTypeRules(FIX::NoOrdTypeRules *arg1) {
    delete arg1;
}

swig_class cInstrumentPartyID;

SWIGINTERN VALUE
_wrap_new_InstrumentPartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrumentPartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyID";
  
  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 ;
  FIX::InstrumentPartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrumentPartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrumentPartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrumentPartyID(FIX::InstrumentPartyID *arg1) {
    delete arg1;
}

swig_class cMarginRatio;

SWIGINTERN VALUE
_wrap_new_MarginRatio__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MarginRatio *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarginRatio";
  
  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 ;
  FIX::MarginRatio *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MarginRatio";
  
  if ((argc < 1) || (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), "in method '" "FIX::MarginRatio" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MarginRatio" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MarginRatio'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MarginRatio(FIX::MarginRatio *arg1) {
    delete arg1;
}

swig_class cRefTagID;

SWIGINTERN VALUE
_wrap_new_RefTagID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::RefTagID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefTagID";
  
  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 ;
  FIX::RefTagID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RefTagID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::RefTagID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RefTagID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RefTagID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RefTagID(FIX::RefTagID *arg1) {
    delete arg1;
}

swig_class cNoRoutingIDs;

SWIGINTERN VALUE
_wrap_new_NoRoutingIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoRoutingIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRoutingIDs";
  
  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 ;
  FIX::NoRoutingIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRoutingIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRoutingIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRoutingIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRoutingIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRoutingIDs(FIX::NoRoutingIDs *arg1) {
    delete arg1;
}

swig_class cCouponRate;

SWIGINTERN VALUE
_wrap_new_CouponRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CouponRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CouponRate";
  
  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 ;
  FIX::CouponRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CouponRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::CouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CouponRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CouponRate(FIX::CouponRate *arg1) {
    delete arg1;
}

swig_class cNoApplIDs;

SWIGINTERN VALUE
_wrap_new_NoApplIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoApplIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoApplIDs";
  
  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 ;
  FIX::NoApplIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoApplIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoApplIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoApplIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoApplIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoApplIDs(FIX::NoApplIDs *arg1) {
    delete arg1;
}

swig_class cDerivativeContractSettlMonth;

SWIGINTERN VALUE
_wrap_new_DerivativeContractSettlMonth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeContractSettlMonth *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractSettlMonth";
  
  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 ;
  FIX::DerivativeContractSettlMonth *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractSettlMonth";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeContractSettlMonth'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeContractSettlMonth(FIX::DerivativeContractSettlMonth *arg1) {
    delete arg1;
}

swig_class cInstrAttribType;

SWIGINTERN VALUE
_wrap_new_InstrAttribType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::InstrAttribType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribType";
  
  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 ;
  FIX::InstrAttribType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::InstrAttribType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::InstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::InstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_InstrAttribType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_InstrAttribType(FIX::InstrAttribType *arg1) {
    delete arg1;
}

swig_class cProduct;

SWIGINTERN VALUE
_wrap_new_Product__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Product *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Product";
  
  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 ;
  FIX::Product *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Product";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Product" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Product" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Product'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Product(FIX::Product *arg1) {
    delete arg1;
}

swig_class cAllocShares;

SWIGINTERN VALUE
_wrap_new_AllocShares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocShares *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocShares";
  
  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 ;
  FIX::AllocShares *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocShares";
  
  if ((argc < 1) || (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), "in method '" "FIX::AllocShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocShares'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocShares(FIX::AllocShares *arg1) {
    delete arg1;
}

swig_class cNoQuoteEntries;

SWIGINTERN VALUE
_wrap_new_NoQuoteEntries__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoQuoteEntries *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteEntries";
  
  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 ;
  FIX::NoQuoteEntries *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoQuoteEntries";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoQuoteEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoQuoteEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoQuoteEntries'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoQuoteEntries(FIX::NoQuoteEntries *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskWarningLevelName;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskWarningLevelName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskWarningLevelName__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskWarningLevelName__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskWarningLevelName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskWarningLevelName(FIX::RelationshipRiskWarningLevelName *arg1) {
    delete arg1;
}

swig_class cDefaultCstmApplVerID;

SWIGINTERN VALUE
_wrap_new_DefaultCstmApplVerID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DefaultCstmApplVerID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultCstmApplVerID";
  
  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 ;
  FIX::DefaultCstmApplVerID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DefaultCstmApplVerID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DefaultCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DefaultCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DefaultCstmApplVerID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DefaultCstmApplVerID(FIX::DefaultCstmApplVerID *arg1) {
    delete arg1;
}

swig_class cDerivativeListMethod;

SWIGINTERN VALUE
_wrap_new_DerivativeListMethod__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeListMethod *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeListMethod";
  
  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 ;
  FIX::DerivativeListMethod *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeListMethod";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeListMethod'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeListMethod(FIX::DerivativeListMethod *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityXMLLen;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityXMLLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityXMLLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLLen";
  
  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 ;
  FIX::DerivativeSecurityXMLLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityXMLLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeSecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityXMLLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityXMLLen(FIX::DerivativeSecurityXMLLen *arg1) {
    delete arg1;
}

swig_class cLegDatedDate;

SWIGINTERN VALUE
_wrap_new_LegDatedDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegDatedDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegDatedDate";
  
  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 ;
  FIX::LegDatedDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegDatedDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegDatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegDatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegDatedDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegDatedDate(FIX::LegDatedDate *arg1) {
    delete arg1;
}

swig_class cNested2PartyIDSource;

SWIGINTERN VALUE
_wrap_new_Nested2PartyIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested2PartyIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyIDSource";
  
  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 ;
  FIX::Nested2PartyIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::Nested2PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested2PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested2PartyIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartyIDSource(FIX::Nested2PartyIDSource *arg1) {
    delete arg1;
}

swig_class cUnderlyingInstrRegistry;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrRegistry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingInstrRegistry *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrRegistry";
  
  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 ;
  FIX::UnderlyingInstrRegistry *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrRegistry";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingInstrRegistry'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrRegistry(FIX::UnderlyingInstrRegistry *arg1) {
    delete arg1;
}

swig_class cIssueDate;

SWIGINTERN VALUE
_wrap_new_IssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IssueDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IssueDate";
  
  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 ;
  FIX::IssueDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IssueDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::IssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IssueDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IssueDate(FIX::IssueDate *arg1) {
    delete arg1;
}

swig_class cSecurityTradingStatus;

SWIGINTERN VALUE
_wrap_new_SecurityTradingStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityTradingStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingStatus";
  
  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 ;
  FIX::SecurityTradingStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityTradingStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityTradingStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityTradingStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityTradingStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityTradingStatus(FIX::SecurityTradingStatus *arg1) {
    delete arg1;
}

swig_class cLegOptAttribute;

SWIGINTERN VALUE
_wrap_new_LegOptAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegOptAttribute *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOptAttribute";
  
  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 ;
  FIX::LegOptAttribute *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegOptAttribute";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegOptAttribute'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegOptAttribute(FIX::LegOptAttribute *arg1) {
    delete arg1;
}

swig_class cMaxFloor;

SWIGINTERN VALUE
_wrap_new_MaxFloor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaxFloor *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxFloor";
  
  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 ;
  FIX::MaxFloor *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaxFloor";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaxFloor" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaxFloor" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaxFloor'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaxFloor(FIX::MaxFloor *arg1) {
    delete arg1;
}

swig_class cDerivativeLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_DerivativeLocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeLocaleOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeLocaleOfIssue";
  
  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 ;
  FIX::DerivativeLocaleOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeLocaleOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeLocaleOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeLocaleOfIssue(FIX::DerivativeLocaleOfIssue *arg1) {
    delete arg1;
}

swig_class cOptPayAmount;

SWIGINTERN VALUE
_wrap_new_OptPayAmount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OptPayAmount *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayAmount";
  
  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 ;
  FIX::OptPayAmount *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OptPayAmount";
  
  if ((argc < 1) || (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), "in method '" "FIX::OptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OptPayAmount'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OptPayAmount(FIX::OptPayAmount *arg1) {
    delete arg1;
}

swig_class cUnderlyingStipType;

SWIGINTERN VALUE
_wrap_new_UnderlyingStipType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingStipType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipType";
  
  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 ;
  FIX::UnderlyingStipType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingStipType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingStipType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingStipType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingStipType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingStipType(FIX::UnderlyingStipType *arg1) {
    delete arg1;
}

swig_class cRule80A;

SWIGINTERN VALUE
_wrap_new_Rule80A__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Rule80A *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Rule80A";
  
  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 ;
  FIX::Rule80A *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Rule80A";
  
  if ((argc < 1) || (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), "in method '" "FIX::Rule80A" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Rule80A" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Rule80A'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Rule80A(FIX::Rule80A *arg1) {
    delete arg1;
}

swig_class cTotNoStrikes;

SWIGINTERN VALUE
_wrap_new_TotNoStrikes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TotNoStrikes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoStrikes";
  
  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 ;
  FIX::TotNoStrikes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TotNoStrikes";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TotNoStrikes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TotNoStrikes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoStrikes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoStrikes(FIX::TotNoStrikes *arg1) {
    delete arg1;
}

swig_class cCorporateAction;

SWIGINTERN VALUE
_wrap_new_CorporateAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CorporateAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CorporateAction";
  
  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 ;
  FIX::CorporateAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CorporateAction";
  
  if ((argc < 1) || (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), "in method '" "FIX::CorporateAction" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CorporateAction" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CorporateAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CorporateAction(FIX::CorporateAction *arg1) {
    delete arg1;
}

swig_class cTerminationType;

SWIGINTERN VALUE
_wrap_new_TerminationType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TerminationType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TerminationType";
  
  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 ;
  FIX::TerminationType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TerminationType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TerminationType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TerminationType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TerminationType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TerminationType(FIX::TerminationType *arg1) {
    delete arg1;
}

swig_class cLegCouponRate;

SWIGINTERN VALUE
_wrap_new_LegCouponRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCouponRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCouponRate";
  
  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 ;
  FIX::LegCouponRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCouponRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCouponRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCouponRate(FIX::LegCouponRate *arg1) {
    delete arg1;
}

swig_class cPosMaintAction;

SWIGINTERN VALUE
_wrap_new_PosMaintAction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosMaintAction *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintAction";
  
  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 ;
  FIX::PosMaintAction *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosMaintAction";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosMaintAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosMaintAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosMaintAction'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosMaintAction(FIX::PosMaintAction *arg1) {
    delete arg1;
}

swig_class cNoSecurityTypes;

SWIGINTERN VALUE
_wrap_new_NoSecurityTypes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoSecurityTypes *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityTypes";
  
  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 ;
  FIX::NoSecurityTypes *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoSecurityTypes";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoSecurityTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoSecurityTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoSecurityTypes'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoSecurityTypes(FIX::NoSecurityTypes *arg1) {
    delete arg1;
}

swig_class cComplexEventPriceTimeType;

SWIGINTERN VALUE
_wrap_new_ComplexEventPriceTimeType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventPriceTimeType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceTimeType";
  
  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 ;
  FIX::ComplexEventPriceTimeType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventPriceTimeType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ComplexEventPriceTimeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventPriceTimeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventPriceTimeType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventPriceTimeType(FIX::ComplexEventPriceTimeType *arg1) {
    delete arg1;
}

swig_class cLastSwapPoints;

SWIGINTERN VALUE
_wrap_new_LastSwapPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LastSwapPoints *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastSwapPoints";
  
  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 ;
  FIX::LastSwapPoints *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LastSwapPoints";
  
  if ((argc < 1) || (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), "in method '" "FIX::LastSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LastSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LastSwapPoints'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LastSwapPoints(FIX::LastSwapPoints *arg1) {
    delete arg1;
}

swig_class cUnderlyingFXRateCalc;

SWIGINTERN VALUE
_wrap_new_UnderlyingFXRateCalc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingFXRateCalc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRateCalc";
  
  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 ;
  FIX::UnderlyingFXRateCalc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingFXRateCalc";
  
  if ((argc < 1) || (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), "in method '" "FIX::UnderlyingFXRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingFXRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingFXRateCalc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingFXRateCalc(FIX::UnderlyingFXRateCalc *arg1) {
    delete arg1;
}

swig_class cListStatusText;

SWIGINTERN VALUE
_wrap_new_ListStatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListStatusText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListStatusText";
  
  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 ;
  FIX::ListStatusText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListStatusText";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListStatusText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListStatusText(FIX::ListStatusText *arg1) {
    delete arg1;
}

swig_class cOddLot;

SWIGINTERN VALUE
_wrap_new_OddLot__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OddLot *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OddLot";
  
  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 ;
  FIX::OddLot *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OddLot";
  
  if ((argc < 1) || (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), "in method '" "FIX::OddLot" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OddLot" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OddLot'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OddLot(FIX::OddLot *arg1) {
    delete arg1;
}

swig_class cBookingUnit;

SWIGINTERN VALUE
_wrap_new_BookingUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BookingUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingUnit";
  
  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 ;
  FIX::BookingUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingUnit";
  
  if ((argc < 1) || (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), "in method '" "FIX::BookingUnit" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BookingUnit" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BookingUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BookingUnit(FIX::BookingUnit *arg1) {
    delete arg1;
}

swig_class cLegAllocAcctIDSource;

SWIGINTERN VALUE
_wrap_new_LegAllocAcctIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegAllocAcctIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAcctIDSource";
  
  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 ;
  FIX::LegAllocAcctIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocAcctIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegAllocAcctIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegAllocAcctIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegAllocAcctIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocAcctIDSource(FIX::LegAllocAcctIDSource *arg1) {
    delete arg1;
}

swig_class cOnBehalfOfSendingTime;

SWIGINTERN VALUE
_wrap_new_OnBehalfOfSendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OnBehalfOfSendingTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  
  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 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  
  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), "in method '" "FIX::OnBehalfOfSendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OnBehalfOfSendingTime";
  
  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), "in method '" "FIX::OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::OnBehalfOfSendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OnBehalfOfSendingTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OnBehalfOfSendingTime(FIX::OnBehalfOfSendingTime *arg1) {
    delete arg1;
}

swig_class cAllocStatus;

SWIGINTERN VALUE
_wrap_new_AllocStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AllocStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocStatus";
  
  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 ;
  FIX::AllocStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AllocStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AllocStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AllocStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AllocStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AllocStatus(FIX::AllocStatus *arg1) {
    delete arg1;
}

swig_class cReferencePage;

SWIGINTERN VALUE
_wrap_new_ReferencePage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ReferencePage *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReferencePage";
  
  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 ;
  FIX::ReferencePage *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReferencePage";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ReferencePage" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ReferencePage" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ReferencePage'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ReferencePage(FIX::ReferencePage *arg1) {
    delete arg1;
}

swig_class cDerivativeExerciseStyle;

SWIGINTERN VALUE
_wrap_new_DerivativeExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeExerciseStyle *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeExerciseStyle";
  
  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 ;
  FIX::DerivativeExerciseStyle *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeExerciseStyle";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeExerciseStyle" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeExerciseStyle" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeExerciseStyle'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeExerciseStyle(FIX::DerivativeExerciseStyle *arg1) {
    delete arg1;
}

swig_class cApplBegSeqNum;

SWIGINTERN VALUE
_wrap_new_ApplBegSeqNum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplBegSeqNum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplBegSeqNum";
  
  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 ;
  FIX::ApplBegSeqNum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplBegSeqNum";
  
  if ((argc < 1) || (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), "in method '" "FIX::ApplBegSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplBegSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplBegSeqNum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplBegSeqNum(FIX::ApplBegSeqNum *arg1) {
    delete arg1;
}

swig_class cCollRptID;

SWIGINTERN VALUE
_wrap_new_CollRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CollRptID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollRptID";
  
  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 ;
  FIX::CollRptID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CollRptID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CollRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CollRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CollRptID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CollRptID(FIX::CollRptID *arg1) {
    delete arg1;
}

swig_class cIncTaxInd;

SWIGINTERN VALUE
_wrap_new_IncTaxInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IncTaxInd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncTaxInd";
  
  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 ;
  FIX::IncTaxInd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IncTaxInd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IncTaxInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IncTaxInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IncTaxInd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IncTaxInd(FIX::IncTaxInd *arg1) {
    delete arg1;
}

swig_class cNoBidDescriptors;

SWIGINTERN VALUE
_wrap_new_NoBidDescriptors__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoBidDescriptors *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoBidDescriptors";
  
  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 ;
  FIX::NoBidDescriptors *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoBidDescriptors";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoBidDescriptors" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoBidDescriptors" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoBidDescriptors'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoBidDescriptors(FIX::NoBidDescriptors *arg1) {
    delete arg1;
}

swig_class cLegCouponPaymentDate;

SWIGINTERN VALUE
_wrap_new_LegCouponPaymentDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegCouponPaymentDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCouponPaymentDate";
  
  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 ;
  FIX::LegCouponPaymentDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegCouponPaymentDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegCouponPaymentDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegCouponPaymentDate(FIX::LegCouponPaymentDate *arg1) {
    delete arg1;
}

swig_class cTotNoPartyList;

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


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

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


SWIGINTERN VALUE _wrap_new_TotNoPartyList(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TotNoPartyList__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoPartyList__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TotNoPartyList'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TotNoPartyList(FIX::TotNoPartyList *arg1) {
    delete arg1;
}

swig_class cPartyListResponseType;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyListResponseType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyListResponseType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyListResponseType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyListResponseType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyListResponseType(FIX::PartyListResponseType *arg1) {
    delete arg1;
}

swig_class cNoUnderlyingLegSecurityAltID;

SWIGINTERN VALUE
_wrap_new_NoUnderlyingLegSecurityAltID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoUnderlyingLegSecurityAltID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingLegSecurityAltID";
  
  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 ;
  FIX::NoUnderlyingLegSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoUnderlyingLegSecurityAltID";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoUnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoUnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoUnderlyingLegSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoUnderlyingLegSecurityAltID(FIX::NoUnderlyingLegSecurityAltID *arg1) {
    delete arg1;
}

swig_class cReversalIndicator;

SWIGINTERN VALUE
_wrap_new_ReversalIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ReversalIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReversalIndicator";
  
  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 ;
  FIX::ReversalIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReversalIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::ReversalIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ReversalIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ReversalIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ReversalIndicator(FIX::ReversalIndicator *arg1) {
    delete arg1;
}

swig_class cCheckSum;

SWIGINTERN VALUE
_wrap_new_CheckSum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CheckSum *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CheckSum";
  
  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 ;
  FIX::CheckSum *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CheckSum";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CheckSum" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CheckSum" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CheckSum'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CheckSum(FIX::CheckSum *arg1) {
    delete arg1;
}

swig_class cTargetSubID;

SWIGINTERN VALUE
_wrap_new_TargetSubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetSubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetSubID";
  
  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 ;
  FIX::TargetSubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetSubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TargetSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetSubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetSubID(FIX::TargetSubID *arg1) {
    delete arg1;
}

swig_class cPosReqStatus;

SWIGINTERN VALUE
_wrap_new_PosReqStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PosReqStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqStatus";
  
  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 ;
  FIX::PosReqStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PosReqStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PosReqStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PosReqStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PosReqStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PosReqStatus(FIX::PosReqStatus *arg1) {
    delete arg1;
}

swig_class cPriorityIndicator;

SWIGINTERN VALUE
_wrap_new_PriorityIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::PriorityIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorityIndicator";
  
  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 ;
  FIX::PriorityIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::PriorityIndicator";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::PriorityIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::PriorityIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PriorityIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PriorityIndicator(FIX::PriorityIndicator *arg1) {
    delete arg1;
}

swig_class cContextPartySubIDType;

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


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

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


SWIGINTERN VALUE _wrap_new_ContextPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ContextPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContextPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContextPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContextPartySubIDType(FIX::ContextPartySubIDType *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegCFICode;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegCFICode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegCFICode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegCFICode";
  
  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 ;
  FIX::UnderlyingLegCFICode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegCFICode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegCFICode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegCFICode(FIX::UnderlyingLegCFICode *arg1) {
    delete arg1;
}

swig_class cDerivativeTimeUnit;

SWIGINTERN VALUE
_wrap_new_DerivativeTimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeTimeUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeTimeUnit";
  
  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 ;
  FIX::DerivativeTimeUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeTimeUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeTimeUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeTimeUnit(FIX::DerivativeTimeUnit *arg1) {
    delete arg1;
}

swig_class cNoNested3PartyIDs;

SWIGINTERN VALUE
_wrap_new_NoNested3PartyIDs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoNested3PartyIDs *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartyIDs";
  
  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 ;
  FIX::NoNested3PartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoNested3PartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoNested3PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoNested3PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoNested3PartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoNested3PartyIDs(FIX::NoNested3PartyIDs *arg1) {
    delete arg1;
}

swig_class cLiquidityPctHigh;

SWIGINTERN VALUE
_wrap_new_LiquidityPctHigh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LiquidityPctHigh *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctHigh";
  
  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 ;
  FIX::LiquidityPctHigh *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LiquidityPctHigh";
  
  if ((argc < 1) || (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), "in method '" "FIX::LiquidityPctHigh" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LiquidityPctHigh" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LiquidityPctHigh'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LiquidityPctHigh(FIX::LiquidityPctHigh *arg1) {
    delete arg1;
}

swig_class cMoneyLaunderingStatus;

SWIGINTERN VALUE
_wrap_new_MoneyLaunderingStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MoneyLaunderingStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MoneyLaunderingStatus";
  
  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 ;
  FIX::MoneyLaunderingStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MoneyLaunderingStatus";
  
  if ((argc < 1) || (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), "in method '" "FIX::MoneyLaunderingStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MoneyLaunderingStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MoneyLaunderingStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MoneyLaunderingStatus(FIX::MoneyLaunderingStatus *arg1) {
    delete arg1;
}

swig_class cNested4PartySubID;

SWIGINTERN VALUE
_wrap_new_Nested4PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested4PartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubID";
  
  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 ;
  FIX::Nested4PartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested4PartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested4PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested4PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested4PartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested4PartySubID(FIX::Nested4PartySubID *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityExchange;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityExchange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityExchange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityExchange";
  
  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 ;
  FIX::DerivativeSecurityExchange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityExchange";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityExchange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityExchange(FIX::DerivativeSecurityExchange *arg1) {
    delete arg1;
}

swig_class cLotType;

SWIGINTERN VALUE
_wrap_new_LotType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LotType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LotType";
  
  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 ;
  FIX::LotType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LotType";
  
  if ((argc < 1) || (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), "in method '" "FIX::LotType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LotType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LotType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LotType(FIX::LotType *arg1) {
    delete arg1;
}

swig_class cContIntRptID;

SWIGINTERN VALUE
_wrap_new_ContIntRptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ContIntRptID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContIntRptID";
  
  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 ;
  FIX::ContIntRptID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ContIntRptID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ContIntRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ContIntRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ContIntRptID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ContIntRptID(FIX::ContIntRptID *arg1) {
    delete arg1;
}

swig_class cQuoteCondition;

SWIGINTERN VALUE
_wrap_new_QuoteCondition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteCondition *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteCondition";
  
  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 ;
  FIX::QuoteCondition *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteCondition";
  
  if ((argc < 1) || (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), "in method '" "FIX::QuoteCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteCondition'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteCondition(FIX::QuoteCondition *arg1) {
    delete arg1;
}

swig_class cComplexEventStartTime;

SWIGINTERN VALUE
_wrap_new_ComplexEventStartTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventStartTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartTime";
  
  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 ;
  FIX::ComplexEventStartTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::ComplexEventStartTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventStartTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventStartTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventStartTime(FIX::ComplexEventStartTime *arg1) {
    delete arg1;
}

swig_class cNoComplexEvents;

SWIGINTERN VALUE
_wrap_new_NoComplexEvents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoComplexEvents *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEvents";
  
  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 ;
  FIX::NoComplexEvents *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoComplexEvents";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoComplexEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoComplexEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoComplexEvents'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoComplexEvents(FIX::NoComplexEvents *arg1) {
    delete arg1;
}

swig_class cDerivativeContractMultiplier;

SWIGINTERN VALUE
_wrap_new_DerivativeContractMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeContractMultiplier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplier";
  
  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 ;
  FIX::DerivativeContractMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeContractMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeContractMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeContractMultiplier(FIX::DerivativeContractMultiplier *arg1) {
    delete arg1;
}

swig_class cDerivativeSecurityStatus;

SWIGINTERN VALUE
_wrap_new_DerivativeSecurityStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeSecurityStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityStatus";
  
  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 ;
  FIX::DerivativeSecurityStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeSecurityStatus";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeSecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeSecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeSecurityStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeSecurityStatus(FIX::DerivativeSecurityStatus *arg1) {
    delete arg1;
}

swig_class cDerivativeProductComplex;

SWIGINTERN VALUE
_wrap_new_DerivativeProductComplex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeProductComplex *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProductComplex";
  
  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 ;
  FIX::DerivativeProductComplex *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeProductComplex";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeProductComplex'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeProductComplex(FIX::DerivativeProductComplex *arg1) {
    delete arg1;
}

swig_class cTriggerSymbol;

SWIGINTERN VALUE
_wrap_new_TriggerSymbol__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TriggerSymbol *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSymbol";
  
  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 ;
  FIX::TriggerSymbol *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TriggerSymbol";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TriggerSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TriggerSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TriggerSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TriggerSymbol(FIX::TriggerSymbol *arg1) {
    delete arg1;
}

swig_class cUnderlyingLocaleOfIssue;

SWIGINTERN VALUE
_wrap_new_UnderlyingLocaleOfIssue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLocaleOfIssue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLocaleOfIssue";
  
  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 ;
  FIX::UnderlyingLocaleOfIssue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLocaleOfIssue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLocaleOfIssue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLocaleOfIssue(FIX::UnderlyingLocaleOfIssue *arg1) {
    delete arg1;
}

swig_class cSendingTime;

SWIGINTERN VALUE
_wrap_new_SendingTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SendingTime *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  
  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 ;
  FIX::SendingTime *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  
  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), "in method '" "FIX::SendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::SendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  
  if ((argc < 1) || (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), "in method '" "FIX::SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::SendingTime *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingTime";
  
  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), "in method '" "FIX::SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::SendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SendingTime'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SendingTime(FIX::SendingTime *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskMaturityMonthYear;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::RelationshipRiskMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::RelationshipRiskMaturityMonthYear *)new FIX::RelationshipRiskMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskMaturityMonthYear__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_RelationshipRiskMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskMaturityMonthYear(FIX::RelationshipRiskMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cRelatedPartyAltIDSource;

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


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

SWIGINTERN VALUE
_wrap_new_RelatedPartyAltIDSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::CHAR *arg1 = 0 ;
  FIX::RelatedPartyAltIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelatedPartyAltIDSource";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelatedPartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelatedPartyAltIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  result = (FIX::RelatedPartyAltIDSource *)new FIX::RelatedPartyAltIDSource((FIX::CHAR const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelatedPartyAltIDSource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedPartyAltIDSource__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_RelatedPartyAltIDSource__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedPartyAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedPartyAltIDSource(FIX::RelatedPartyAltIDSource *arg1) {
    delete arg1;
}

swig_class cComplexEventStartDate;

SWIGINTERN VALUE
_wrap_new_ComplexEventStartDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ComplexEventStartDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  
  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 ;
  FIX::ComplexEventStartDate *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  
  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), "in method '" "FIX::ComplexEventStartDate" "', argument " "1"" of type '" "bool""'");
  } 
  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 ;
  FIX::ComplexEventStartDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  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 ;
  FIX::ComplexEventStartDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ComplexEventStartDate";
  
  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), "in method '" "FIX::ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ComplexEventStartDate" "', argument " "2"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ComplexEventStartDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ComplexEventStartDate(FIX::ComplexEventStartDate *arg1) {
    delete arg1;
}

swig_class cUnderlyingRestructuringType;

SWIGINTERN VALUE
_wrap_new_UnderlyingRestructuringType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingRestructuringType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRestructuringType";
  
  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 ;
  FIX::UnderlyingRestructuringType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingRestructuringType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingRestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingRestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingRestructuringType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingRestructuringType(FIX::UnderlyingRestructuringType *arg1) {
    delete arg1;
}

swig_class cLegUnitOfMeasureQty;

SWIGINTERN VALUE
_wrap_new_LegUnitOfMeasureQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegUnitOfMeasureQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasureQty";
  
  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 ;
  FIX::LegUnitOfMeasureQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegUnitOfMeasureQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegUnitOfMeasureQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegUnitOfMeasureQty(FIX::LegUnitOfMeasureQty *arg1) {
    delete arg1;
}

swig_class cNoTrdRegTimestamps;

SWIGINTERN VALUE
_wrap_new_NoTrdRegTimestamps__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoTrdRegTimestamps *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRegTimestamps";
  
  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 ;
  FIX::NoTrdRegTimestamps *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoTrdRegTimestamps";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoTrdRegTimestamps" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoTrdRegTimestamps" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoTrdRegTimestamps'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoTrdRegTimestamps(FIX::NoTrdRegTimestamps *arg1) {
    delete arg1;
}

swig_class cSendingDate;

SWIGINTERN VALUE
_wrap_new_SendingDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SendingDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingDate";
  
  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 ;
  FIX::SendingDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SendingDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::SendingDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SendingDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SendingDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SendingDate(FIX::SendingDate *arg1) {
    delete arg1;
}

swig_class cPartyRelationship;

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


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

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


SWIGINTERN VALUE _wrap_new_PartyRelationship(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_PartyRelationship__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyRelationship__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_PartyRelationship'");
  return Qnil;
}


SWIGINTERN void
free_FIX_PartyRelationship(FIX::PartyRelationship *arg1) {
    delete arg1;
}

swig_class cTimeToExpiration;

SWIGINTERN VALUE
_wrap_new_TimeToExpiration__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TimeToExpiration *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeToExpiration";
  
  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 ;
  FIX::TimeToExpiration *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TimeToExpiration";
  
  if ((argc < 1) || (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), "in method '" "FIX::TimeToExpiration" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TimeToExpiration" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TimeToExpiration'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TimeToExpiration(FIX::TimeToExpiration *arg1) {
    delete arg1;
}

swig_class cLegAllocQty;

SWIGINTERN VALUE
_wrap_new_LegAllocQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegAllocQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocQty";
  
  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 ;
  FIX::LegAllocQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegAllocQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegAllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegAllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegAllocQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegAllocQty(FIX::LegAllocQty *arg1) {
    delete arg1;
}

swig_class cSettlLocation;

SWIGINTERN VALUE
_wrap_new_SettlLocation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlLocation *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlLocation";
  
  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 ;
  FIX::SettlLocation *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlLocation";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SettlLocation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlLocation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlLocation'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlLocation(FIX::SettlLocation *arg1) {
    delete arg1;
}

swig_class cUnderlyingExerciseStyle;

SWIGINTERN VALUE
_wrap_new_UnderlyingExerciseStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingExerciseStyle *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingExerciseStyle";
  
  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 ;
  FIX::UnderlyingExerciseStyle *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingExerciseStyle";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingExerciseStyle'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingExerciseStyle(FIX::UnderlyingExerciseStyle *arg1) {
    delete arg1;
}

swig_class cCashSettlAgentContactName;

SWIGINTERN VALUE
_wrap_new_CashSettlAgentContactName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CashSettlAgentContactName *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactName";
  
  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 ;
  FIX::CashSettlAgentContactName *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CashSettlAgentContactName";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CashSettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CashSettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CashSettlAgentContactName'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CashSettlAgentContactName(FIX::CashSettlAgentContactName *arg1) {
    delete arg1;
}

swig_class cLegRepurchaseRate;

SWIGINTERN VALUE
_wrap_new_LegRepurchaseRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegRepurchaseRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseRate";
  
  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 ;
  FIX::LegRepurchaseRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegRepurchaseRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegRepurchaseRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegRepurchaseRate(FIX::LegRepurchaseRate *arg1) {
    delete arg1;
}

swig_class cApplResponseID;

SWIGINTERN VALUE
_wrap_new_ApplResponseID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplResponseID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseID";
  
  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 ;
  FIX::ApplResponseID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplResponseID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplResponseID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplResponseID(FIX::ApplResponseID *arg1) {
    delete arg1;
}

swig_class cNoDerivativeInstrAttrib;

SWIGINTERN VALUE
_wrap_new_NoDerivativeInstrAttrib__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoDerivativeInstrAttrib *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrAttrib";
  
  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 ;
  FIX::NoDerivativeInstrAttrib *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoDerivativeInstrAttrib";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoDerivativeInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoDerivativeInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoDerivativeInstrAttrib'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoDerivativeInstrAttrib(FIX::NoDerivativeInstrAttrib *arg1) {
    delete arg1;
}

swig_class cDerivativeStrikeMultiplier;

SWIGINTERN VALUE
_wrap_new_DerivativeStrikeMultiplier__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeStrikeMultiplier *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeMultiplier";
  
  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 ;
  FIX::DerivativeStrikeMultiplier *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeStrikeMultiplier";
  
  if ((argc < 1) || (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), "in method '" "FIX::DerivativeStrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeStrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeStrikeMultiplier'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeStrikeMultiplier(FIX::DerivativeStrikeMultiplier *arg1) {
    delete arg1;
}

swig_class cLegStrikeCurrency;

SWIGINTERN VALUE
_wrap_new_LegStrikeCurrency__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegStrikeCurrency *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStrikeCurrency";
  
  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 ;
  FIX::LegStrikeCurrency *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegStrikeCurrency";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegStrikeCurrency'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegStrikeCurrency(FIX::LegStrikeCurrency *arg1) {
    delete arg1;
}

swig_class cSecurityStatusReqID;

SWIGINTERN VALUE
_wrap_new_SecurityStatusReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecurityStatusReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatusReqID";
  
  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 ;
  FIX::SecurityStatusReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecurityStatusReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecurityStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecurityStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecurityStatusReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecurityStatusReqID(FIX::SecurityStatusReqID *arg1) {
    delete arg1;
}

swig_class cSecureDataLen;

SWIGINTERN VALUE
_wrap_new_SecureDataLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecureDataLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecureDataLen";
  
  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 ;
  FIX::SecureDataLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecureDataLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::SecureDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecureDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecureDataLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecureDataLen(FIX::SecureDataLen *arg1) {
    delete arg1;
}

swig_class cDiscretionScope;

SWIGINTERN VALUE
_wrap_new_DiscretionScope__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionScope *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionScope";
  
  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 ;
  FIX::DiscretionScope *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionScope";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DiscretionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionScope'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionScope(FIX::DiscretionScope *arg1) {
    delete arg1;
}

swig_class cOwnerType;

SWIGINTERN VALUE
_wrap_new_OwnerType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OwnerType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OwnerType";
  
  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 ;
  FIX::OwnerType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OwnerType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OwnerType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OwnerType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OwnerType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OwnerType(FIX::OwnerType *arg1) {
    delete arg1;
}

swig_class cShares;

SWIGINTERN VALUE
_wrap_new_Shares__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Shares *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Shares";
  
  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 ;
  FIX::Shares *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Shares";
  
  if ((argc < 1) || (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), "in method '" "FIX::Shares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Shares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Shares'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Shares(FIX::Shares *arg1) {
    delete arg1;
}

swig_class cYield;

SWIGINTERN VALUE
_wrap_new_Yield__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Yield *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Yield";
  
  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 ;
  FIX::Yield *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Yield";
  
  if ((argc < 1) || (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), "in method '" "FIX::Yield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Yield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Yield'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Yield(FIX::Yield *arg1) {
    delete arg1;
}

swig_class cQuoteRespID;

SWIGINTERN VALUE
_wrap_new_QuoteRespID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteRespID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespID";
  
  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 ;
  FIX::QuoteRespID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteRespID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteRespID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteRespID(FIX::QuoteRespID *arg1) {
    delete arg1;
}

swig_class cRiskMaturityMonthYear;

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


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

SWIGINTERN VALUE
_wrap_new_RiskMaturityMonthYear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::MONTHYEAR *arg1 = 0 ;
  FIX::RiskMaturityMonthYear *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskMaturityMonthYear";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  result = (FIX::RiskMaturityMonthYear *)new FIX::RiskMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskMaturityMonthYear(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskMaturityMonthYear__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_RiskMaturityMonthYear__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskMaturityMonthYear'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskMaturityMonthYear(FIX::RiskMaturityMonthYear *arg1) {
    delete arg1;
}

swig_class cNested3PartySubID;

SWIGINTERN VALUE
_wrap_new_Nested3PartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested3PartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubID";
  
  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 ;
  FIX::Nested3PartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested3PartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested3PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested3PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested3PartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested3PartySubID(FIX::Nested3PartySubID *arg1) {
    delete arg1;
}

swig_class cApplQueueResolution;

SWIGINTERN VALUE
_wrap_new_ApplQueueResolution__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplQueueResolution *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueResolution";
  
  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 ;
  FIX::ApplQueueResolution *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplQueueResolution";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplQueueResolution" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplQueueResolution" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplQueueResolution'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplQueueResolution(FIX::ApplQueueResolution *arg1) {
    delete arg1;
}

swig_class cTrdRegTimestampOrigin;

SWIGINTERN VALUE
_wrap_new_TrdRegTimestampOrigin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TrdRegTimestampOrigin *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampOrigin";
  
  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 ;
  FIX::TrdRegTimestampOrigin *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TrdRegTimestampOrigin";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TrdRegTimestampOrigin" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TrdRegTimestampOrigin" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TrdRegTimestampOrigin'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TrdRegTimestampOrigin(FIX::TrdRegTimestampOrigin *arg1) {
    delete arg1;
}

swig_class cNested2PartyRole;

SWIGINTERN VALUE
_wrap_new_Nested2PartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested2PartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyRole";
  
  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 ;
  FIX::Nested2PartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested2PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested2PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested2PartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartyRole(FIX::Nested2PartyRole *arg1) {
    delete arg1;
}

swig_class cNested2PartyID;

SWIGINTERN VALUE
_wrap_new_Nested2PartyID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Nested2PartyID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyID";
  
  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 ;
  FIX::Nested2PartyID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Nested2PartyID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Nested2PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Nested2PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Nested2PartyID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Nested2PartyID(FIX::Nested2PartyID *arg1) {
    delete arg1;
}

swig_class cBidSize;

SWIGINTERN VALUE
_wrap_new_BidSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidSize *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSize";
  
  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 ;
  FIX::BidSize *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidSize";
  
  if ((argc < 1) || (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), "in method '" "FIX::BidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidSize'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidSize(FIX::BidSize *arg1) {
    delete arg1;
}

swig_class cLegSymbolSfx;

SWIGINTERN VALUE
_wrap_new_LegSymbolSfx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegSymbolSfx *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSymbolSfx";
  
  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 ;
  FIX::LegSymbolSfx *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegSymbolSfx";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::LegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegSymbolSfx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegSymbolSfx(FIX::LegSymbolSfx *arg1) {
    delete arg1;
}

swig_class cQuoteResponseLevel;

SWIGINTERN VALUE
_wrap_new_QuoteResponseLevel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteResponseLevel *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteResponseLevel";
  
  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 ;
  FIX::QuoteResponseLevel *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteResponseLevel";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteResponseLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteResponseLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteResponseLevel'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteResponseLevel(FIX::QuoteResponseLevel *arg1) {
    delete arg1;
}

swig_class cBodyLength;

SWIGINTERN VALUE
_wrap_new_BodyLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BodyLength *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BodyLength";
  
  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 ;
  FIX::BodyLength *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BodyLength";
  
  if ((argc < 1) || (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), "in method '" "FIX::BodyLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BodyLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BodyLength'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BodyLength(FIX::BodyLength *arg1) {
    delete arg1;
}

swig_class cListExecInst;

SWIGINTERN VALUE
_wrap_new_ListExecInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ListExecInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListExecInst";
  
  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 ;
  FIX::ListExecInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ListExecInst";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ListExecInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ListExecInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ListExecInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ListExecInst(FIX::ListExecInst *arg1) {
    delete arg1;
}

swig_class cExecAckStatus;

SWIGINTERN VALUE
_wrap_new_ExecAckStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecAckStatus *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecAckStatus";
  
  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 ;
  FIX::ExecAckStatus *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecAckStatus";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecAckStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecAckStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecAckStatus'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecAckStatus(FIX::ExecAckStatus *arg1) {
    delete arg1;
}

swig_class cSettlDate2;

SWIGINTERN VALUE
_wrap_new_SettlDate2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlDate2 *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDate2";
  
  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 ;
  FIX::SettlDate2 *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlDate2";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlDate2'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlDate2(FIX::SettlDate2 *arg1) {
    delete arg1;
}

swig_class cNetGrossInd;

SWIGINTERN VALUE
_wrap_new_NetGrossInd__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NetGrossInd *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetGrossInd";
  
  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 ;
  FIX::NetGrossInd *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetGrossInd";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NetGrossInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NetGrossInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetGrossInd'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NetGrossInd(FIX::NetGrossInd *arg1) {
    delete arg1;
}

swig_class cUnderlyingSecurityAltIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingSecurityAltIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingSecurityAltIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltIDSource";
  
  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 ;
  FIX::UnderlyingSecurityAltIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingSecurityAltIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingSecurityAltIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingSecurityAltIDSource(FIX::UnderlyingSecurityAltIDSource *arg1) {
    delete arg1;
}

swig_class cTestReqID;

SWIGINTERN VALUE
_wrap_new_TestReqID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TestReqID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TestReqID";
  
  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 ;
  FIX::TestReqID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TestReqID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TestReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TestReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TestReqID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TestReqID(FIX::TestReqID *arg1) {
    delete arg1;
}

swig_class cCxlType;

SWIGINTERN VALUE
_wrap_new_CxlType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CxlType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlType";
  
  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 ;
  FIX::CxlType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CxlType";
  
  if ((argc < 1) || (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), "in method '" "FIX::CxlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CxlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CxlType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CxlType(FIX::CxlType *arg1) {
    delete arg1;
}

swig_class cUnderlyingCreditRating;

SWIGINTERN VALUE
_wrap_new_UnderlyingCreditRating__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCreditRating *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCreditRating";
  
  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 ;
  FIX::UnderlyingCreditRating *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCreditRating";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCreditRating'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCreditRating(FIX::UnderlyingCreditRating *arg1) {
    delete arg1;
}

swig_class cAvgPxPrecision;

SWIGINTERN VALUE
_wrap_new_AvgPxPrecision__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AvgPxPrecision *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPxPrecision";
  
  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 ;
  FIX::AvgPxPrecision *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AvgPxPrecision";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::AvgPxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AvgPxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AvgPxPrecision'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AvgPxPrecision(FIX::AvgPxPrecision *arg1) {
    delete arg1;
}

swig_class cBenchmarkPriceType;

SWIGINTERN VALUE
_wrap_new_BenchmarkPriceType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BenchmarkPriceType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPriceType";
  
  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 ;
  FIX::BenchmarkPriceType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BenchmarkPriceType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BenchmarkPriceType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BenchmarkPriceType(FIX::BenchmarkPriceType *arg1) {
    delete arg1;
}

swig_class cDeskTypeSource;

SWIGINTERN VALUE
_wrap_new_DeskTypeSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DeskTypeSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskTypeSource";
  
  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 ;
  FIX::DeskTypeSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DeskTypeSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DeskTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DeskTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DeskTypeSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DeskTypeSource(FIX::DeskTypeSource *arg1) {
    delete arg1;
}

swig_class cDiscretionRoundDirection;

SWIGINTERN VALUE
_wrap_new_DiscretionRoundDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionRoundDirection *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionRoundDirection";
  
  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 ;
  FIX::DiscretionRoundDirection *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionRoundDirection";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DiscretionRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionRoundDirection'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionRoundDirection(FIX::DiscretionRoundDirection *arg1) {
    delete arg1;
}

swig_class cOrigSecondaryTradeID;

SWIGINTERN VALUE
_wrap_new_OrigSecondaryTradeID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrigSecondaryTradeID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSecondaryTradeID";
  
  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 ;
  FIX::OrigSecondaryTradeID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrigSecondaryTradeID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::OrigSecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrigSecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrigSecondaryTradeID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrigSecondaryTradeID(FIX::OrigSecondaryTradeID *arg1) {
    delete arg1;
}

swig_class cReceivedDeptID;

SWIGINTERN VALUE
_wrap_new_ReceivedDeptID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ReceivedDeptID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReceivedDeptID";
  
  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 ;
  FIX::ReceivedDeptID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ReceivedDeptID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ReceivedDeptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ReceivedDeptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ReceivedDeptID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ReceivedDeptID(FIX::ReceivedDeptID *arg1) {
    delete arg1;
}

swig_class cMaturityNetMoney;

SWIGINTERN VALUE
_wrap_new_MaturityNetMoney__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MaturityNetMoney *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityNetMoney";
  
  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 ;
  FIX::MaturityNetMoney *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MaturityNetMoney";
  
  if ((argc < 1) || (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), "in method '" "FIX::MaturityNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MaturityNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MaturityNetMoney'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MaturityNetMoney(FIX::MaturityNetMoney *arg1) {
    delete arg1;
}

swig_class cBidDescriptorType;

SWIGINTERN VALUE
_wrap_new_BidDescriptorType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BidDescriptorType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptorType";
  
  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 ;
  FIX::BidDescriptorType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BidDescriptorType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BidDescriptorType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BidDescriptorType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BidDescriptorType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BidDescriptorType(FIX::BidDescriptorType *arg1) {
    delete arg1;
}

swig_class cRiskEncodedSecurityDescLen;

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


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

SWIGINTERN VALUE
_wrap_new_RiskEncodedSecurityDescLen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::LENGTH *arg1 = 0 ;
  FIX::RiskEncodedSecurityDescLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RiskEncodedSecurityDescLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::RiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RiskEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  result = (FIX::RiskEncodedSecurityDescLen *)new FIX::RiskEncodedSecurityDescLen((FIX::LENGTH const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RiskEncodedSecurityDescLen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskEncodedSecurityDescLen__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_RiskEncodedSecurityDescLen__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskEncodedSecurityDescLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskEncodedSecurityDescLen(FIX::RiskEncodedSecurityDescLen *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSymbol;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSymbol(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSymbol__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSymbol__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSymbol'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSymbol(FIX::RelationshipRiskSymbol *arg1) {
    delete arg1;
}

swig_class cNoRelatedContextPartyIDs;

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


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

SWIGINTERN VALUE
_wrap_new_NoRelatedContextPartyIDs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRelatedContextPartyIDs *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRelatedContextPartyIDs";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRelatedContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRelatedContextPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRelatedContextPartyIDs *)new FIX::NoRelatedContextPartyIDs((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRelatedContextPartyIDs(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRelatedContextPartyIDs__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_NoRelatedContextPartyIDs__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRelatedContextPartyIDs'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRelatedContextPartyIDs(FIX::NoRelatedContextPartyIDs *arg1) {
    delete arg1;
}

swig_class cDerivativeInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_DerivativeInstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativeInstrumentPartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubID";
  
  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 ;
  FIX::DerivativeInstrumentPartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativeInstrumentPartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativeInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativeInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativeInstrumentPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativeInstrumentPartySubID(FIX::DerivativeInstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class cNetworkStatusResponseType;

SWIGINTERN VALUE
_wrap_new_NetworkStatusResponseType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NetworkStatusResponseType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkStatusResponseType";
  
  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 ;
  FIX::NetworkStatusResponseType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NetworkStatusResponseType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::NetworkStatusResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NetworkStatusResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NetworkStatusResponseType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NetworkStatusResponseType(FIX::NetworkStatusResponseType *arg1) {
    delete arg1;
}

swig_class cDateOfBirth;

SWIGINTERN VALUE
_wrap_new_DateOfBirth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DateOfBirth *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DateOfBirth";
  
  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 ;
  FIX::DateOfBirth *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DateOfBirth";
  
  if ((argc < 1) || (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), "in method '" "FIX::DateOfBirth" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DateOfBirth" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DateOfBirth'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DateOfBirth(FIX::DateOfBirth *arg1) {
    delete arg1;
}

swig_class cRelatedContextPartySubIDType;

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


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

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


SWIGINTERN VALUE _wrap_new_RelatedContextPartySubIDType(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelatedContextPartySubIDType__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatedContextPartySubIDType__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelatedContextPartySubIDType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelatedContextPartySubIDType(FIX::RelatedContextPartySubIDType *arg1) {
    delete arg1;
}

swig_class cStartStrikePxRange;

SWIGINTERN VALUE
_wrap_new_StartStrikePxRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StartStrikePxRange *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartStrikePxRange";
  
  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 ;
  FIX::StartStrikePxRange *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StartStrikePxRange";
  
  if ((argc < 1) || (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), "in method '" "FIX::StartStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StartStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StartStrikePxRange'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StartStrikePxRange(FIX::StartStrikePxRange *arg1) {
    delete arg1;
}

swig_class cUndlyInstrumentPartySubID;

SWIGINTERN VALUE
_wrap_new_UndlyInstrumentPartySubID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UndlyInstrumentPartySubID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubID";
  
  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 ;
  FIX::UndlyInstrumentPartySubID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UndlyInstrumentPartySubID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UndlyInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UndlyInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UndlyInstrumentPartySubID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UndlyInstrumentPartySubID(FIX::UndlyInstrumentPartySubID *arg1) {
    delete arg1;
}

swig_class cSecondaryTradeReportRefID;

SWIGINTERN VALUE
_wrap_new_SecondaryTradeReportRefID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SecondaryTradeReportRefID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportRefID";
  
  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 ;
  FIX::SecondaryTradeReportRefID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SecondaryTradeReportRefID";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::SecondaryTradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SecondaryTradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SecondaryTradeReportRefID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SecondaryTradeReportRefID(FIX::SecondaryTradeReportRefID *arg1) {
    delete arg1;
}

swig_class cUnderlyingCPRegType;

SWIGINTERN VALUE
_wrap_new_UnderlyingCPRegType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingCPRegType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPRegType";
  
  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 ;
  FIX::UnderlyingCPRegType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingCPRegType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingCPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingCPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingCPRegType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingCPRegType(FIX::UnderlyingCPRegType *arg1) {
    delete arg1;
}

swig_class cSignatureLength;

SWIGINTERN VALUE
_wrap_new_SignatureLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SignatureLength *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SignatureLength";
  
  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 ;
  FIX::SignatureLength *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SignatureLength";
  
  if ((argc < 1) || (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), "in method '" "FIX::SignatureLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SignatureLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SignatureLength'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SignatureLength(FIX::SignatureLength *arg1) {
    delete arg1;
}

swig_class cOrderQty;

SWIGINTERN VALUE
_wrap_new_OrderQty__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OrderQty *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderQty";
  
  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 ;
  FIX::OrderQty *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OrderQty";
  
  if ((argc < 1) || (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), "in method '" "FIX::OrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OrderQty'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OrderQty(FIX::OrderQty *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskWarningLevelPercent;

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


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

SWIGINTERN VALUE
_wrap_new_RelationshipRiskWarningLevelPercent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::PERCENTAGE *arg1 = 0 ;
  FIX::RelationshipRiskWarningLevelPercent *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::RelationshipRiskWarningLevelPercent";
  
  if ((argc < 1) || (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), "in method '" "FIX::RelationshipRiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::RelationshipRiskWarningLevelPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  result = (FIX::RelationshipRiskWarningLevelPercent *)new FIX::RelationshipRiskWarningLevelPercent((FIX::PERCENTAGE const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RelationshipRiskWarningLevelPercent(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskWarningLevelPercent__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_RelationshipRiskWarningLevelPercent__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskWarningLevelPercent'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskWarningLevelPercent(FIX::RelationshipRiskWarningLevelPercent *arg1) {
    delete arg1;
}

swig_class cOriginalNotionalPercentageOutstanding;

SWIGINTERN VALUE
_wrap_new_OriginalNotionalPercentageOutstanding__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::OriginalNotionalPercentageOutstanding *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OriginalNotionalPercentageOutstanding";
  
  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 ;
  FIX::OriginalNotionalPercentageOutstanding *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::OriginalNotionalPercentageOutstanding";
  
  if ((argc < 1) || (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), "in method '" "FIX::OriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::OriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_OriginalNotionalPercentageOutstanding'");
  return Qnil;
}


SWIGINTERN void
free_FIX_OriginalNotionalPercentageOutstanding(FIX::OriginalNotionalPercentageOutstanding *arg1) {
    delete arg1;
}

swig_class cUnderlyingTimeUnit;

SWIGINTERN VALUE
_wrap_new_UnderlyingTimeUnit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingTimeUnit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTimeUnit";
  
  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 ;
  FIX::UnderlyingTimeUnit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingTimeUnit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingTimeUnit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingTimeUnit(FIX::UnderlyingTimeUnit *arg1) {
    delete arg1;
}

swig_class cEncodedHeadlineLen;

SWIGINTERN VALUE
_wrap_new_EncodedHeadlineLen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedHeadlineLen *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadlineLen";
  
  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 ;
  FIX::EncodedHeadlineLen *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedHeadlineLen";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedHeadlineLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedHeadlineLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedHeadlineLen'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedHeadlineLen(FIX::EncodedHeadlineLen *arg1) {
    delete arg1;
}

swig_class cNoRegistDtls;

SWIGINTERN VALUE
_wrap_new_NoRegistDtls__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoRegistDtls *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRegistDtls";
  
  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 ;
  FIX::NoRegistDtls *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRegistDtls";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRegistDtls" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRegistDtls" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRegistDtls'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRegistDtls(FIX::NoRegistDtls *arg1) {
    delete arg1;
}

swig_class cStrategyParameterValue;

SWIGINTERN VALUE
_wrap_new_StrategyParameterValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StrategyParameterValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterValue";
  
  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 ;
  FIX::StrategyParameterValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StrategyParameterValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StrategyParameterValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StrategyParameterValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrategyParameterValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StrategyParameterValue(FIX::StrategyParameterValue *arg1) {
    delete arg1;
}

swig_class cRiskSecurityDesc;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecurityDesc(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityDesc__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecurityDesc__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityDesc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityDesc(FIX::RiskSecurityDesc *arg1) {
    delete arg1;
}

swig_class cNoInstrumentParties;

SWIGINTERN VALUE
_wrap_new_NoInstrumentParties__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoInstrumentParties *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentParties";
  
  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 ;
  FIX::NoInstrumentParties *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoInstrumentParties";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoInstrumentParties'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoInstrumentParties(FIX::NoInstrumentParties *arg1) {
    delete arg1;
}

swig_class cQuoteType;

SWIGINTERN VALUE
_wrap_new_QuoteType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::QuoteType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteType";
  
  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 ;
  FIX::QuoteType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::QuoteType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::QuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::QuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_QuoteType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_QuoteType(FIX::QuoteType *arg1) {
    delete arg1;
}

swig_class cNoRiskSecurityAltID;

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


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

SWIGINTERN VALUE
_wrap_new_NoRiskSecurityAltID__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FIX::NUMINGROUP *arg1 = 0 ;
  FIX::NoRiskSecurityAltID *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoRiskSecurityAltID";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoRiskSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  result = (FIX::NoRiskSecurityAltID *)new FIX::NoRiskSecurityAltID((FIX::NUMINGROUP const &)*arg1);DATA_PTR(self) = result;
  
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NoRiskSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_NoRiskSecurityAltID__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_NoRiskSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoRiskSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoRiskSecurityAltID(FIX::NoRiskSecurityAltID *arg1) {
    delete arg1;
}

swig_class cNoStrategyParameters;

SWIGINTERN VALUE
_wrap_new_NoStrategyParameters__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::NoStrategyParameters *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrategyParameters";
  
  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 ;
  FIX::NoStrategyParameters *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NoStrategyParameters";
  
  if ((argc < 1) || (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), "in method '" "FIX::NoStrategyParameters" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::NoStrategyParameters" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_NoStrategyParameters'");
  return Qnil;
}


SWIGINTERN void
free_FIX_NoStrategyParameters(FIX::NoStrategyParameters *arg1) {
    delete arg1;
}

swig_class cIndividualAllocRejCode;

SWIGINTERN VALUE
_wrap_new_IndividualAllocRejCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IndividualAllocRejCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocRejCode";
  
  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 ;
  FIX::IndividualAllocRejCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IndividualAllocRejCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::IndividualAllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IndividualAllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IndividualAllocRejCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IndividualAllocRejCode(FIX::IndividualAllocRejCode *arg1) {
    delete arg1;
}

swig_class cDiscretionInst;

SWIGINTERN VALUE
_wrap_new_DiscretionInst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DiscretionInst *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionInst";
  
  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 ;
  FIX::DiscretionInst *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DiscretionInst";
  
  if ((argc < 1) || (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), "in method '" "FIX::DiscretionInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DiscretionInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DiscretionInst'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DiscretionInst(FIX::DiscretionInst *arg1) {
    delete arg1;
}

swig_class cRiskSecurityAltID;

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


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

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


SWIGINTERN VALUE _wrap_new_RiskSecurityAltID(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RiskSecurityAltID__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskSecurityAltID__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RiskSecurityAltID'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RiskSecurityAltID(FIX::RiskSecurityAltID *arg1) {
    delete arg1;
}

swig_class cTargetPartyRole;

SWIGINTERN VALUE
_wrap_new_TargetPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TargetPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyRole";
  
  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 ;
  FIX::TargetPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TargetPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TargetPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TargetPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TargetPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TargetPartyRole(FIX::TargetPartyRole *arg1) {
    delete arg1;
}

swig_class cCrossPrioritization;

SWIGINTERN VALUE
_wrap_new_CrossPrioritization__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::CrossPrioritization *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossPrioritization";
  
  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 ;
  FIX::CrossPrioritization *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::CrossPrioritization";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::CrossPrioritization" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::CrossPrioritization" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_CrossPrioritization'");
  return Qnil;
}


SWIGINTERN void
free_FIX_CrossPrioritization(FIX::CrossPrioritization *arg1) {
    delete arg1;
}

swig_class cEncodedListStatusText;

SWIGINTERN VALUE
_wrap_new_EncodedListStatusText__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::EncodedListStatusText *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusText";
  
  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 ;
  FIX::EncodedListStatusText *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::EncodedListStatusText";
  
  if ((argc < 1) || (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), "in method '" "FIX::EncodedListStatusText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::EncodedListStatusText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_EncodedListStatusText'");
  return Qnil;
}


SWIGINTERN void
free_FIX_EncodedListStatusText(FIX::EncodedListStatusText *arg1) {
    delete arg1;
}

swig_class cIOIOthSvc;

SWIGINTERN VALUE
_wrap_new_IOIOthSvc__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::IOIOthSvc *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIOthSvc";
  
  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 ;
  FIX::IOIOthSvc *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::IOIOthSvc";
  
  if ((argc < 1) || (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), "in method '" "FIX::IOIOthSvc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::IOIOthSvc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_IOIOthSvc'");
  return Qnil;
}


SWIGINTERN void
free_FIX_IOIOthSvc(FIX::IOIOthSvc *arg1) {
    delete arg1;
}

swig_class cLegIssueDate;

SWIGINTERN VALUE
_wrap_new_LegIssueDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::LegIssueDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIssueDate";
  
  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 ;
  FIX::LegIssueDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::LegIssueDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::LegIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::LegIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_LegIssueDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_LegIssueDate(FIX::LegIssueDate *arg1) {
    delete arg1;
}

swig_class cMDReqRejReason;

SWIGINTERN VALUE
_wrap_new_MDReqRejReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::MDReqRejReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReqRejReason";
  
  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 ;
  FIX::MDReqRejReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MDReqRejReason";
  
  if ((argc < 1) || (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), "in method '" "FIX::MDReqRejReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::MDReqRejReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_MDReqRejReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_MDReqRejReason(FIX::MDReqRejReason *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskPutOrCall;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskPutOrCall(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskPutOrCall__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskPutOrCall__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskPutOrCall'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskPutOrCall(FIX::RelationshipRiskPutOrCall *arg1) {
    delete arg1;
}

swig_class cApplReqType;

SWIGINTERN VALUE
_wrap_new_ApplReqType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ApplReqType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReqType";
  
  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 ;
  FIX::ApplReqType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ApplReqType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::ApplReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ApplReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ApplReqType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ApplReqType(FIX::ApplReqType *arg1) {
    delete arg1;
}

swig_class cCountry;

SWIGINTERN VALUE
_wrap_new_Country__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::Country *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Country";
  
  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 ;
  FIX::Country *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Country";
  
  if ((argc < 1) || (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), "in method '" "FIX::Country" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Country" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Country'");
  return Qnil;
}


SWIGINTERN void
free_FIX_Country(FIX::Country *arg1) {
    delete arg1;
}

swig_class cUnderlyingLegSecurityIDSource;

SWIGINTERN VALUE
_wrap_new_UnderlyingLegSecurityIDSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingLegSecurityIDSource *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityIDSource";
  
  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 ;
  FIX::UnderlyingLegSecurityIDSource *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingLegSecurityIDSource";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingLegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingLegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingLegSecurityIDSource'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingLegSecurityIDSource(FIX::UnderlyingLegSecurityIDSource *arg1) {
    delete arg1;
}

swig_class cFlexProductEligibilityIndicator;

SWIGINTERN VALUE
_wrap_new_FlexProductEligibilityIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FlexProductEligibilityIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlexProductEligibilityIndicator";
  
  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 ;
  FIX::FlexProductEligibilityIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FlexProductEligibilityIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::FlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FlexProductEligibilityIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_FlexProductEligibilityIndicator(FIX::FlexProductEligibilityIndicator *arg1) {
    delete arg1;
}

swig_class cAggressorIndicator;

SWIGINTERN VALUE
_wrap_new_AggressorIndicator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::AggressorIndicator *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AggressorIndicator";
  
  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 ;
  FIX::AggressorIndicator *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::AggressorIndicator";
  
  if ((argc < 1) || (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), "in method '" "FIX::AggressorIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::AggressorIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_AggressorIndicator'");
  return Qnil;
}


SWIGINTERN void
free_FIX_AggressorIndicator(FIX::AggressorIndicator *arg1) {
    delete arg1;
}

swig_class cExecPriceAdjustment;

SWIGINTERN VALUE
_wrap_new_ExecPriceAdjustment__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ExecPriceAdjustment *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceAdjustment";
  
  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 ;
  FIX::ExecPriceAdjustment *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ExecPriceAdjustment";
  
  if ((argc < 1) || (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), "in method '" "FIX::ExecPriceAdjustment" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ExecPriceAdjustment" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ExecPriceAdjustment'");
  return Qnil;
}


SWIGINTERN void
free_FIX_ExecPriceAdjustment(FIX::ExecPriceAdjustment *arg1) {
    delete arg1;
}

swig_class cBusinessRejectReason;

SWIGINTERN VALUE
_wrap_new_BusinessRejectReason__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BusinessRejectReason *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectReason";
  
  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 ;
  FIX::BusinessRejectReason *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BusinessRejectReason";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BusinessRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BusinessRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BusinessRejectReason'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BusinessRejectReason(FIX::BusinessRejectReason *arg1) {
    delete arg1;
}

swig_class cTradeDate;

SWIGINTERN VALUE
_wrap_new_TradeDate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TradeDate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeDate";
  
  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 ;
  FIX::TradeDate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TradeDate";
  
  if ((argc < 1) || (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), "in method '" "FIX::TradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TradeDate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TradeDate(FIX::TradeDate *arg1) {
    delete arg1;
}

swig_class cUnderlyingPutOrCall;

SWIGINTERN VALUE
_wrap_new_UnderlyingPutOrCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingPutOrCall *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPutOrCall";
  
  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 ;
  FIX::UnderlyingPutOrCall *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingPutOrCall";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingPutOrCall'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingPutOrCall(FIX::UnderlyingPutOrCall *arg1) {
    delete arg1;
}

swig_class cRelationshipRiskSymbolSfx;

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


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

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


SWIGINTERN VALUE _wrap_new_RelationshipRiskSymbolSfx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ii++) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_RelationshipRiskSymbolSfx__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelationshipRiskSymbolSfx__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_RelationshipRiskSymbolSfx'");
  return Qnil;
}


SWIGINTERN void
free_FIX_RelationshipRiskSymbolSfx(FIX::RelationshipRiskSymbolSfx *arg1) {
    delete arg1;
}

swig_class cUnderlyingInstrumentPartyRole;

SWIGINTERN VALUE
_wrap_new_UnderlyingInstrumentPartyRole__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::UnderlyingInstrumentPartyRole *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyRole";
  
  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 ;
  FIX::UnderlyingInstrumentPartyRole *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::UnderlyingInstrumentPartyRole";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::UnderlyingInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::UnderlyingInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_UnderlyingInstrumentPartyRole'");
  return Qnil;
}


SWIGINTERN void
free_FIX_UnderlyingInstrumentPartyRole(FIX::UnderlyingInstrumentPartyRole *arg1) {
    delete arg1;
}

swig_class cDerivativePositionLimit;

SWIGINTERN VALUE
_wrap_new_DerivativePositionLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DerivativePositionLimit *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePositionLimit";
  
  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 ;
  FIX::DerivativePositionLimit *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DerivativePositionLimit";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::DerivativePositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DerivativePositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DerivativePositionLimit'");
  return Qnil;
}


SWIGINTERN void
free_FIX_DerivativePositionLimit(FIX::DerivativePositionLimit *arg1) {
    delete arg1;
}

swig_class cTierCode;

SWIGINTERN VALUE
_wrap_new_TierCode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::TierCode *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TierCode";
  
  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 ;
  FIX::TierCode *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::TierCode";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::TierCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::TierCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_TierCode'");
  return Qnil;
}


SWIGINTERN void
free_FIX_TierCode(FIX::TierCode *arg1) {
    delete arg1;
}

swig_class cBookingType;

SWIGINTERN VALUE
_wrap_new_BookingType__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::BookingType *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingType";
  
  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 ;
  FIX::BookingType *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::BookingType";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__INT,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::BookingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::BookingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_BookingType'");
  return Qnil;
}


SWIGINTERN void
free_FIX_BookingType(FIX::BookingType *arg1) {
    delete arg1;
}

swig_class cStipulationValue;

SWIGINTERN VALUE
_wrap_new_StipulationValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::StipulationValue *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StipulationValue";
  
  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 ;
  FIX::StipulationValue *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::StipulationValue";
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__STRING,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::StipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::StipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_StipulationValue'");
  return Qnil;
}


SWIGINTERN void
free_FIX_StipulationValue(FIX::StipulationValue *arg1) {
    delete arg1;
}

swig_class cSettlCurrBidFxRate;

SWIGINTERN VALUE
_wrap_new_SettlCurrBidFxRate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SettlCurrBidFxRate *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrBidFxRate";
  
  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 ;
  FIX::SettlCurrBidFxRate *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SettlCurrBidFxRate";
  
  if ((argc < 1) || (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), "in method '" "FIX::SettlCurrBidFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SettlCurrBidFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SettlCurrBidFxRate'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SettlCurrBidFxRate(FIX::SettlCurrBidFxRate *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
BeginString_FIXT11_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIXT11);
  return _val;
}


SWIGINTERN VALUE
BeginString_FIX50_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX50);
  return _val;
}


SWIGINTERN VALUE
BeginString_FIX44_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX44);
  return _val;
}


SWIGINTERN VALUE
BeginString_FIX43_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX43);
  return _val;
}


SWIGINTERN VALUE
BeginString_FIX42_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX42);
  return _val;
}


SWIGINTERN VALUE
BeginString_FIX41_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX41);
  return _val;
}


SWIGINTERN VALUE
BeginString_FIX40_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BeginString_FIX40);
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_TAG_NUMBER_TEXT);
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_REQUIRED_TAG_MISSING_TEXT);
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_UNDEFINED_TAG_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_UNDEFINED_TAG_TEXT);
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_VALUE_IS_INCORRECT_TEXT);
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_DECRYPTION_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_SIGNATURE_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_COMPID_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_COMPID_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT);
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_INVALID_MSGTYPE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_MSGTYPE_TEXT);
  return _val;
}


SWIGINTERN VALUE
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
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
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
BusinessRejectReason_OTHER_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_OTHER_TEXT);
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNKNOWN_ID_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_ID_TEXT);
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_SECURITY_TEXT);
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT);
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT);
  return _val;
}


SWIGINTERN VALUE
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
BusinessRejectReason_NOT_AUTHORIZED_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BusinessRejectReason_NOT_AUTHORIZED_TEXT);
  return _val;
}


SWIGINTERN VALUE
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
DeliveryForm_BOOKENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOKENTRY));
  return _val;
}


SWIGINTERN VALUE
DeliveryForm_BEARER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BEARER));
  return _val;
}


SWIGINTERN VALUE
DeliveryForm_BOOK_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOK_ENTRY));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_GTRENEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GTRENEW));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_WAREHOUSE_RECAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_WAREHOUSE_RECAP));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_CANCELEDNOTBEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCELEDNOTBEST));
  return _val;
}


SWIGINTERN VALUE
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
ExecRestatementReason_CXLTRADINGHALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLTRADINGHALT));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecRestatementReason_PEG_REFRESH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PEG_REFRESH));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_VERBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_VERBAL));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecRestatementReason_REPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_REPX));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_MRKTOPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_MRKTOPTION));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_VERBAL_CHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_VERBAL_CHANGE));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_PARTDEC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PARTDEC));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_CXLSYSTEMFAILURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CXLSYSTEMFAILURE));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_GTCORPACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GTCORPACT));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_BROKER_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_BROKER_OPTION));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_WAREHOUSERECAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_WAREHOUSERECAP));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_BRKROPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_BRKROPT));
  return _val;
}


SWIGINTERN VALUE
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
ExecRestatementReason_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_MARKET));
  return _val;
}


SWIGINTERN VALUE
ExecRestatementReason_GT_RENEWAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_RENEWAL));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_PENDING_RELEASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_RELEASE));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_PENDING_REVERSAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_REVERSAL));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_ACCOUNTLEVELREJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCOUNTLEVELREJECT));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_PENDINGACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDINGACCEPT));
  return _val;
}


SWIGINTERN VALUE
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
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
AllocIntermedReqType_BLOCKLEVELREJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_BLOCKLEVELREJECT));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_PENDING_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_PENDINGREVERSAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDINGREVERSAL));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_PENDINGRELEASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDINGRELEASE));
  return _val;
}


SWIGINTERN VALUE
AllocIntermedReqType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
SecurityListTypeSource_GICS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_GICS));
  return _val;
}


SWIGINTERN VALUE
SecurityListTypeSource_NAICS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_NAICS));
  return _val;
}


SWIGINTERN VALUE
SecurityListTypeSource_ICB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_ICB));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_PARTIALLY_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_PARTIALLY_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_OUTSTANDING_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_OUTSTANDING_TRADES));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_SUBSTITUTIONELIGIBLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_SUBSTITUTIONELIGIBLE));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_TRADE_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADE_DATE));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_FULLYASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_FULLYASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_SUBSTITUTION_ELIGIBLE));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_FULLY_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_FULLY_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_NOTASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_NOTASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_GCINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_GCINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_NOT_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_NOT_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_COLLATERAL_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERAL_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_OUTSTANDINGTRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_OUTSTANDINGTRADES));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_TRADEDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADEDATE));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_GC_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_GC_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_PARTIALLYASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_PARTIALLYASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryQualifier_COLLATERALINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERALINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
EmailType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::EmailType_NEW));
  return _val;
}


SWIGINTERN VALUE
EmailType_REPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::EmailType_REPLY));
  return _val;
}


SWIGINTERN VALUE
EmailType_ADMIN_REPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::EmailType_ADMIN_REPLY));
  return _val;
}


SWIGINTERN VALUE
EmailType_ADMINREPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::EmailType_ADMINREPLY));
  return _val;
}


SWIGINTERN VALUE
IOIQltyInd_MEDIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_MEDIUM));
  return _val;
}


SWIGINTERN VALUE
IOIQltyInd_HIGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_HIGH));
  return _val;
}


SWIGINTERN VALUE
IOIQltyInd_LOW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_LOW));
  return _val;
}


SWIGINTERN VALUE
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
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
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
AccountType_ACCOUNTCUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNTCUSTOMER));
  return _val;
}


SWIGINTERN VALUE
AccountType_HOUSE_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSE_TRADER));
  return _val;
}


SWIGINTERN VALUE
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
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
AccountType_FLOOR_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_FLOOR_TRADER));
  return _val;
}


SWIGINTERN VALUE
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
AccountType_HOUSETRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSETRADER));
  return _val;
}


SWIGINTERN VALUE
AccountType_FLOORTRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_FLOORTRADER));
  return _val;
}


SWIGINTERN VALUE
AccountType_ACCOUNTNONCUSTOMERCROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNTNONCUSTOMERCROSS));
  return _val;
}


SWIGINTERN VALUE
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
AccountType_ACCOUNTNONCUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNTNONCUSTOMER));
  return _val;
}


SWIGINTERN VALUE
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
AccountType_HOUSETRADERCROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSETRADERCROSS));
  return _val;
}


SWIGINTERN VALUE
AccountType_JOINTBOACCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AccountType_JOINTBOACCT));
  return _val;
}


SWIGINTERN VALUE
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
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
HaltReasonInt_ADDITIONAL_INFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ADDITIONAL_INFORMATION));
  return _val;
}


SWIGINTERN VALUE
HaltReasonInt_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_PENDING));
  return _val;
}


SWIGINTERN VALUE
HaltReasonInt_ORDER_INFLUX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_INFLUX));
  return _val;
}


SWIGINTERN VALUE
HaltReasonInt_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_DISSEMINATION));
  return _val;
}


SWIGINTERN VALUE
HaltReasonInt_EQUIPMENT_CHANGEOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_EQUIPMENT_CHANGEOVER));
  return _val;
}


SWIGINTERN VALUE
HaltReasonInt_ORDER_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_3RDYEARDELEGATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_3RDYEARDELEGATE);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_FULLASSOCIATEMEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FULLASSOCIATEMEMBER);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_106H_AND_106J_FIRMS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_106H_AND_106J_FIRMS);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_4THYEARDELEGATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_4THYEARDELEGATE);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_5THYEARDELEGATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_5THYEARDELEGATE);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_EQUITYCLEARINGMEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_EQUITYCLEARINGMEMBER);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_2NDYEARDELEGATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_2NDYEARDELEGATE);
  return _val;
}


SWIGINTERN VALUE
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
ClearingFeeIndicator_1STYEARDELEGATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_1STYEARDELEGATE);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_106H106J_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_106H106J);
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_106F_EMPLOYEES);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_6THYEARDELEGATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_6THYEARDELEGATE);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER);
  return _val;
}


SWIGINTERN VALUE
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
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
ClearingFeeIndicator_CBOE_MEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_CBOE_MEMBER);
  return _val;
}


SWIGINTERN VALUE
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
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
ClearingFeeIndicator_NONMEMBERCUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_NONMEMBERCUSTOMER);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES);
  return _val;
}


SWIGINTERN VALUE
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
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
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
ClearingFeeIndicator_CBOEMEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_CBOEMEMBER);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_LESSEE106F_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE106F);
  return _val;
}


SWIGINTERN VALUE
ClearingFeeIndicator_ALLOTHERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_ALLOTHERS);
  return _val;
}


SWIGINTERN VALUE
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
ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES);
  return _val;
}


SWIGINTERN VALUE
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
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
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
BidType_DISCLOSED_STYLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_STYLE));
  return _val;
}


SWIGINTERN VALUE
BidType_NONDISC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_NONDISC));
  return _val;
}


SWIGINTERN VALUE
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
BidType_DISC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_DISC));
  return _val;
}


SWIGINTERN VALUE
BidType_DISCLOSED_SYTLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_SYTLE));
  return _val;
}


SWIGINTERN VALUE
BidType_NOBID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidType_NOBID));
  return _val;
}


SWIGINTERN VALUE
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
QuotePriceType_PER_SHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PER_SHARE));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_TEDPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TEDPRICE));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_PERSHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERSHARE));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_FIXED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_FIXED_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_TED_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_YIELD));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_PREMIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PREMIUM));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_FIXEDAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_FIXEDAMOUNT));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_YIELDSPREADSWAPS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELDSPREADSWAPS));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_TEDYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TEDYIELD));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_DISCOUNT));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_YIELD_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD_SPREAD));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_TED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_PRICE));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERCENT));
  return _val;
}


SWIGINTERN VALUE
QuotePriceType_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_SPREAD));
  return _val;
}


SWIGINTERN VALUE
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
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
MultilegPriceMethod_MULTIPLIED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_MULTIPLIED_PRICE));
  return _val;
}


SWIGINTERN VALUE
MultilegPriceMethod_INDIVIDUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_INDIVIDUAL));
  return _val;
}


SWIGINTERN VALUE
MultilegPriceMethod_YIELD_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_YIELD_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
MultilegPriceMethod_NET_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_NET_PRICE));
  return _val;
}


SWIGINTERN VALUE
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
ListMethod_USER_REQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListMethod_USER_REQUESTED));
  return _val;
}


SWIGINTERN VALUE
MDImplicitDelete_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_NO));
  return _val;
}


SWIGINTERN VALUE
MDImplicitDelete_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_YES));
  return _val;
}


SWIGINTERN VALUE
RoutingType_BLOCKLIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCKLIST));
  return _val;
}


SWIGINTERN VALUE
RoutingType_TARGET_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_LIST));
  return _val;
}


SWIGINTERN VALUE
RoutingType_TARGET_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_FIRM));
  return _val;
}


SWIGINTERN VALUE
RoutingType_TARGETFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGETFIRM));
  return _val;
}


SWIGINTERN VALUE
RoutingType_TARGETLIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGETLIST));
  return _val;
}


SWIGINTERN VALUE
RoutingType_BLOCK_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_LIST));
  return _val;
}


SWIGINTERN VALUE
RoutingType_BLOCK_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_FIRM));
  return _val;
}


SWIGINTERN VALUE
RoutingType_BLOCKFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCKFIRM));
  return _val;
}


SWIGINTERN VALUE
BidTradeType_RISKTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_RISKTRADE));
  return _val;
}


SWIGINTERN VALUE
BidTradeType_VWAPGUARANTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_VWAPGUARANTEE));
  return _val;
}


SWIGINTERN VALUE
BidTradeType_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_AGENCY));
  return _val;
}


SWIGINTERN VALUE
BidTradeType_GUARANTEEDCLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_GUARANTEEDCLOSE));
  return _val;
}


SWIGINTERN VALUE
BidTradeType_VWAP_GUARANTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_VWAP_GUARANTEE));
  return _val;
}


SWIGINTERN VALUE
BidTradeType_RISK_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_RISK_TRADE));
  return _val;
}


SWIGINTERN VALUE
BidTradeType_GUARANTEED_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidTradeType_GUARANTEED_CLOSE));
  return _val;
}


SWIGINTERN VALUE
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
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
OrdRejReason_DUPLICATEVERBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATEVERBAL));
  return _val;
}


SWIGINTERN VALUE
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
OrdRejReason_EXCHANGE_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCHANGE_CLOSED));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_DUPLICATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_SURVEILLENCE_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLENCE_OPTION));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_UNKNOWN_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ORDER));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_INCORRECTALLOCATEDQUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECTALLOCATEDQUANTITY));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_TOOLATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TOOLATE));
  return _val;
}


SWIGINTERN VALUE
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
OrdRejReason_DUPLICATE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_ORDER));
  return _val;
}


SWIGINTERN VALUE
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
OrdRejReason_INCORRECT_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_UNKNOWNSYM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWNSYM));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_STALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_STALE));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_UNKNOWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
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
OrdRejReason_BROKEROPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKEROPT));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_EXCEEDSLIM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCEEDSLIM));
  return _val;
}


SWIGINTERN VALUE
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
OrdRejReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_INCORRECTQUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECTQUANTITY));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_UNKNOWNACCOUNTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWNACCOUNTS));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_BROKER_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER_OPTION));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_SURVEILLENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLENCE));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_EXCHCLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCHCLOSED));
  return _val;
}


SWIGINTERN VALUE
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
OrdRejReason_INVINVID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVINVID));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_UNSUPPORDERCHAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNSUPPORDERCHAR));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_TRADEALONGREQ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TRADEALONGREQ));
  return _val;
}


SWIGINTERN VALUE
OrdRejReason_UNKNOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN));
  return _val;
}


SWIGINTERN VALUE
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
OrdRejReason_STALE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_STALE_ORDER));
  return _val;
}


SWIGINTERN VALUE
MaturityMonthYearIncrementUnits_WEEKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_WEEKS));
  return _val;
}


SWIGINTERN VALUE
MaturityMonthYearIncrementUnits_MONTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_MONTHS));
  return _val;
}


SWIGINTERN VALUE
MaturityMonthYearIncrementUnits_YEARS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_YEARS));
  return _val;
}


SWIGINTERN VALUE
MaturityMonthYearIncrementUnits_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_DAYS));
  return _val;
}


SWIGINTERN VALUE
DisplayWhen_EXHAUST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_EXHAUST));
  return _val;
}


SWIGINTERN VALUE
DisplayWhen_IMMEDIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_IMMEDIATE));
  return _val;
}


SWIGINTERN VALUE
ApplQueueAction_END_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_END_SESSION));
  return _val;
}


SWIGINTERN VALUE
ApplQueueAction_QUEUEFLUSHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_QUEUEFLUSHED));
  return _val;
}


SWIGINTERN VALUE
ApplQueueAction_QUEUE_FLUSHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_QUEUE_FLUSHED));
  return _val;
}


SWIGINTERN VALUE
ApplQueueAction_ENDSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_ENDSESSION));
  return _val;
}


SWIGINTERN VALUE
ApplQueueAction_OVERLAYLAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_OVERLAYLAST));
  return _val;
}


SWIGINTERN VALUE
ApplQueueAction_OVERLAY_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_OVERLAY_LAST));
  return _val;
}


SWIGINTERN VALUE
ApplQueueAction_NOACTIONTAKEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_NOACTIONTAKEN));
  return _val;
}


SWIGINTERN VALUE
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
RegistTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
RegistTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
RegistTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
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
PriceType_FIXEDCABINETTRADEPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXEDCABINETTRADEPRICE));
  return _val;
}


SWIGINTERN VALUE
PriceType_PER_SHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_SHARE));
  return _val;
}


SWIGINTERN VALUE
PriceType_PCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PCT));
  return _val;
}


SWIGINTERN VALUE
PriceType_VARIABLECABINETTRADEPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_VARIABLECABINETTRADEPRICE));
  return _val;
}


SWIGINTERN VALUE
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
PriceType_TEDPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_TEDPRICE));
  return _val;
}


SWIGINTERN VALUE
PriceType_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_YIELD));
  return _val;
}


SWIGINTERN VALUE
PriceType_TED_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_YIELD));
  return _val;
}


SWIGINTERN VALUE
PriceType_PREMIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PREMIUM));
  return _val;
}


SWIGINTERN VALUE
PriceType_FIXED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
PriceType_TEDYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_TEDYIELD));
  return _val;
}


SWIGINTERN VALUE
PriceType_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_DISCOUNT));
  return _val;
}


SWIGINTERN VALUE
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
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
PriceType_CPS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_CPS));
  return _val;
}


SWIGINTERN VALUE
PriceType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
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
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
PriceType_ABS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_ABS));
  return _val;
}


SWIGINTERN VALUE
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
PriceType_PER_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_UNIT));
  return _val;
}


SWIGINTERN VALUE
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
PriceType_TED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_PRICE));
  return _val;
}


SWIGINTERN VALUE
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
PriceType_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceType_SPREAD));
  return _val;
}


SWIGINTERN VALUE
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
SettlObligMode_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
SettlObligMode_FINAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_FINAL));
  return _val;
}


SWIGINTERN VALUE
SecurityUpdateAction_DELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_DELETE));
  return _val;
}


SWIGINTERN VALUE
SecurityUpdateAction_ADD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_ADD));
  return _val;
}


SWIGINTERN VALUE
SecurityUpdateAction_MODIFY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_MODIFY));
  return _val;
}


SWIGINTERN VALUE
NetworkRequestType_STOP_SUBSCRIBING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_STOP_SUBSCRIBING));
  return _val;
}


SWIGINTERN VALUE
NetworkRequestType_LEVELOFDETAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_LEVELOFDETAIL));
  return _val;
}


SWIGINTERN VALUE
NetworkRequestType_SUBSCRIBE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SUBSCRIBE));
  return _val;
}


SWIGINTERN VALUE
NetworkRequestType_SNAPSHOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SNAPSHOT));
  return _val;
}


SWIGINTERN VALUE
NetworkRequestType_STOPSUBSCRIBING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_STOPSUBSCRIBING));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_TRADER_MNEMONIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRADER_MNEMONIC));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ACCEPTABLE_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_CONTRATRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRATRADER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_EXECUTINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTINGFIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CUSTOMER_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTOMER_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_POSITIONACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_POSITIONACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_REPORT_ORIGINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORT_ORIGINATOR));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CONTRAFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRAFIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_EXECUTION_VENUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTION_VENUE));
  return _val;
}


SWIGINTERN VALUE
PartyRole_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_INTRODUCING_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_BROKER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_FOREIGN_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_FOREIGN_FIRM));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_EXECUTINGSYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTINGSYSTEM));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_INVESTMENT_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTMENT_FIRM));
  return _val;
}


SWIGINTERN VALUE
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
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
PartyRole_SYSTEMATIC_INTERNALISER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SYSTEMATIC_INTERNALISER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_LOCATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATE));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CORRESPONDENTCLEARINGORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENTCLEARINGORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_SUB_CUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SUB_CUSTODIAN));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ENTERING_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_UNIT));
  return _val;
}


SWIGINTERN VALUE
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
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
PartyRole_SENDER_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SENDER_LOCATION));
  return _val;
}


SWIGINTERN VALUE
PartyRole_REGULATED_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATED_MARKET));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_SETTLEMENTLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENTLOCATION));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_QUOTE_ORIGINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_QUOTE_ORIGINATOR));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CLEARING_ORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
PartyRole_SESSION_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SESSION_ID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_INTERESTED_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERESTED_PARTY));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_CONTRA_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_TRADER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ENTERINGTRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERINGTRADER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ENTERING_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_TRADER));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_BENEFICIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BENEFICIARY));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_FORIEGN_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_FORIEGN_FIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_SETTLEMENT_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENT_LOCATION));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CLEARINGORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARINGORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
PartyRole_EXECUTING_SYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_SYSTEM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CLEARING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_FIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_PLEDGEE_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGEE_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CLIENT_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLIENT_ID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ENTERING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_FIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ALLOCENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ALLOCENTITY));
  return _val;
}


SWIGINTERN VALUE
PartyRole_INVESTOR_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTOR_ID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CLEARINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARINGFIRM));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_SUBCUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SUBCUSTODIAN));
  return _val;
}


SWIGINTERN VALUE
PartyRole_BUYER_SELLER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BUYER_SELLER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CLEARING_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ENTERINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERINGFIRM));
  return _val;
}


SWIGINTERN VALUE
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
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
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
PartyRole_CUSTOMERACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTOMERACCOUNT));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_INTRODUCINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCINGFIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_EXECUTING_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_UNIT));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_INTERESTEDPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERESTEDPARTY));
  return _val;
}


SWIGINTERN VALUE
PartyRole_LOCATION_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATION_ID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ORDERORIGINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDERORIGINATOR));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CORRESPONDENT_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_BROKER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ASSET_MANAGER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ASSET_MANAGER));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_SPONSORINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SPONSORINGFIRM));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_CONTRA_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
PartyRole_INVESTORID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTORID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_FUNDMANAGER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_FUNDMANAGER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_REGULATORYBODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATORYBODY));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CONTRA_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_FIRM));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_LIQUIDITYPROVIDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LIQUIDITYPROVIDER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_GIVEUPCLEARINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_GIVEUPCLEARINGFIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CONTRACLEARINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRACLEARINGFIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CLAIMING_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLAIMING_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_INTRODUCING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_FIRM));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_EXECUTINGTRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTINGTRADER));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_EXECUTING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_FIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_AGENT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_LIQUIDITY_PROVIDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LIQUIDITY_PROVIDER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_POSITION_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_POSITION_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_BROKEROFCREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKEROFCREDIT));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_CLIENTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLIENTID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_PLEDGOR_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGOR_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartyRole_REPORTING_INTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORTING_INTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
PartyRole_EXECUTING_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_TRADER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTODIAN));
  return _val;
}


SWIGINTERN VALUE
PartyRole_BROKERCLEARINGID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKERCLEARINGID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CORRESPONDENTBROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENTBROKER));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_INITIATINGTRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_INITIATINGTRADER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_REGULATORY_BODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATORY_BODY));
  return _val;
}


SWIGINTERN VALUE
PartyRole_UNACCEPTABLE_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
PartyRole_CORRESPONDANTCLEARINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDANTCLEARINGFIRM));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_BUYERSELLERRECEIVERDELIVERER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_BUYERSELLERRECEIVERDELIVERER));
  return _val;
}


SWIGINTERN VALUE
PartyRole_DESK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_DESK_ID));
  return _val;
}


SWIGINTERN VALUE
PartyRole_ALLOCATION_ENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_ALLOCATION_ENTITY));
  return _val;
}


SWIGINTERN VALUE
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
PartyRole_SPONSORING_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_SPONSORING_FIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_LOCATELENDINGFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATELENDINGFIRM));
  return _val;
}


SWIGINTERN VALUE
PartyRole_UNDRCONTRAFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNDRCONTRAFIRM));
  return _val;
}


SWIGINTERN VALUE
AssignmentMethod_PRO_RATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRO_RATA));
  return _val;
}


SWIGINTERN VALUE
AssignmentMethod_RANDOM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_RANDOM));
  return _val;
}


SWIGINTERN VALUE
AssignmentMethod_PRORATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRORATA));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_MONTHYEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MONTHYEAR));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_TZTIMEONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMEONLY));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_QTY));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_BOOLEAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_BOOLEAN));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_MULTIPLECHARVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLECHARVALUE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_CHAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CHAR));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_NUMINGROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_NUMINGROUP));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_TAGNUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TAGNUM));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_COUNTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_COUNTRY));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_TENOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TENOR));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_LOCALMKTTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTTIME));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_INT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_INT));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_LOCALMKTDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTDATE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_LANGUAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LANGUAGE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_MONTH_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MONTH_YEAR));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_LENGTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LENGTH));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_TZTIMESTAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMESTAMP));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_MULTIPLESTRINGVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLESTRINGVALUE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_UTCTIMESTAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMESTAMP));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_DATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_DATA));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CURRENCY));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_STRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_STRING));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_AMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_AMT));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_FLOAT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_FLOAT));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_UTCDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATE));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_UTCTIMEONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMEONLY));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_SEQNUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_SEQNUM));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_UTCDATEONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATEONLY));
  return _val;
}


SWIGINTERN VALUE
StrategyParameterType_PRICEOFFSET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICEOFFSET));
  return _val;
}


SWIGINTERN VALUE
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
EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_PKCS_DES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS_DES));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_NONEOTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONEOTHER));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_PKCSDESPROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCSDESPROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_PGPDESDEFUNCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGPDESDEFUNCT));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_PKCS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_PGP_DES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGP_DES));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_DES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_DES));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_PKCSPROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCSPROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_NONE_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE_OTHER));
  return _val;
}


SWIGINTERN VALUE
EncryptMethod_DESECBMODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_DESECBMODE));
  return _val;
}


SWIGINTERN VALUE
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
PosAmtType_ACCRUED_COUPON_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_ACCRUED_COUPON_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_PREMIUM_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_PREMIUM_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_INCREMENTALMARKTOMARKETAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTALMARKTOMARKETAMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_CASHAMOUNTCORPORATEEVENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_CASHAMOUNTCORPORATEEVENT);
  return _val;
}


SWIGINTERN VALUE
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
PosAmtType_TOTAL_BANKED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_BANKED_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
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
PosAmtType_SETTLEMENT_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_SETTLEMENT_VALUE);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_VALUEADJUSTEDAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_VALUEADJUSTEDAMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_CASH_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_CASH_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_PREMIUMAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_PREMIUMAMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_INITIAL_TRADE_COUPON_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_INCREMENTAL_ACCRUED_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_ACCRUED_COUPON);
  return _val;
}


SWIGINTERN VALUE
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
PosAmtType_VALUE_ADJUSTED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_VALUE_ADJUSTED_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_CASHRESIDUALAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_CASHRESIDUALAMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_COLLATERALIZED_MARK_TO_MARKET);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_CASH_RESIDUAL_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_CASH_RESIDUAL_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_COMPENSATION_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_COMPENSATION_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_TRADE_VARIATION_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_TRADE_VARIATION_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_TRADEVARIATIONAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_TRADEVARIATIONAMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_FINALMARKTOMARKETAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_FINALMARKTOMARKETAMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_COUPON_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_COUPON_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_COLLATERALIZED_AMOUNT);
  return _val;
}


SWIGINTERN VALUE
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
ResetSeqNumFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_NO));
  return _val;
}


SWIGINTERN VALUE
ResetSeqNumFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_YES));
  return _val;
}


SWIGINTERN VALUE
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
CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
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
CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE));
  return _val;
}


SWIGINTERN VALUE
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
CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryResult_INVALIDPARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDPARTIES));
  return _val;
}


SWIGINTERN VALUE
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
CollInquiryResult_INVALIDDESTINATIONREQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALIDDESTINATIONREQUESTED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryResult_SUCCESSFUL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_SUCCESSFUL));
  return _val;
}


SWIGINTERN VALUE
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
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
CollInquiryResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY));
  return _val;
}


SWIGINTERN VALUE
CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryResult_INVALID_PARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_PARTIES));
  return _val;
}


SWIGINTERN VALUE
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
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
CollAsgnRespType_DECLINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_DECLINED));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRespType_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRespType_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_REJECTED));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRespType_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
UnsolicitedIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
UnsolicitedIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_UNKNWNSYM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNWNSYM));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_EXCHCLSD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXCHCLSD));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_EXHCNAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXHCNAGE));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_DUPORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_DUPORD));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_INVALID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_PRICE));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_TOOLATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_TOOLATE));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_INVBIDASK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVBIDASK));
  return _val;
}


SWIGINTERN VALUE
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
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
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
QuoteEntryRejectReason_ORDEXCLIM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_ORDEXCLIM));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_UNKNORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNORD));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_INVPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVPX));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_NOTAUTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_NOTAUTH));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
QuoteEntryRejectReason_UNKNOWN_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_QUOTE));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryRejectReason_DUPLICATE_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_DUPLICATE_QUOTE));
  return _val;
}


SWIGINTERN VALUE
OrderCapacity_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
OrderCapacity_RISKLESS_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_RISKLESS_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
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
OrderCapacity_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
OrderCapacity_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENCY));
  return _val;
}


SWIGINTERN VALUE
OrderCapacity_INDIVIDUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_INDIVIDUAL));
  return _val;
}


SWIGINTERN VALUE
OrderCapacity_AGENTOTHERMEMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENTOTHERMEMBER));
  return _val;
}


SWIGINTERN VALUE
OrderCapacity_RISKLESSPRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_RISKLESSPRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
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
QuoteAckStatus_CANCELED_ALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_ALL));
  return _val;
}


SWIGINTERN VALUE
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
QuoteAckStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
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
QuoteAckStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
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
UserRequestType_CHANGEPASSWORDFORUSER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_CHANGEPASSWORDFORUSER));
  return _val;
}


SWIGINTERN VALUE
UserRequestType_LOGOFFUSER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGOFFUSER));
  return _val;
}


SWIGINTERN VALUE
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
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
UserRequestType_REQUESTINDIVIDUALUSERSTATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_REQUESTINDIVIDUALUSERSTATUS));
  return _val;
}


SWIGINTERN VALUE
UserRequestType_LOGONUSER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGONUSER));
  return _val;
}


SWIGINTERN VALUE
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
TradeReportTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
TradeReportTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
TradeReportTransType_REVERSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REVERSE));
  return _val;
}


SWIGINTERN VALUE
TradeReportTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
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
TradeReportTransType_RELEASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_RELEASE));
  return _val;
}


SWIGINTERN VALUE
AdvSide_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_CROSS));
  return _val;
}


SWIGINTERN VALUE
AdvSide_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_TRADE));
  return _val;
}


SWIGINTERN VALUE
AdvSide_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_BUY));
  return _val;
}


SWIGINTERN VALUE
AdvSide_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AdvSide_SELL));
  return _val;
}


SWIGINTERN VALUE
CoveredOrUncovered_COVERED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_COVERED));
  return _val;
}


SWIGINTERN VALUE
CoveredOrUncovered_UNCOVERED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_UNCOVERED));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_TFMGSPTA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_TFMGSPTA));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_TFM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_TFM));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_DTCCCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_DTCCCODE));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_SIDCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SIDCODE));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_OMGEOALERTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OMGEOALERTID));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_BIC));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OTHER));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_OMGEO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OMGEO));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_SID_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SID_CODE));
  return _val;
}


SWIGINTERN VALUE
AcctIDSource_DTCC_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_DTCC_CODE));
  return _val;
}


SWIGINTERN VALUE
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
TradeRequestType_ALL_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ALL_TRADES));
  return _val;
}


SWIGINTERN VALUE
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
TradeRequestType_UNREPORTEDTRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNREPORTEDTRADES));
  return _val;
}


SWIGINTERN VALUE
TradeRequestType_ALLTRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ALLTRADES));
  return _val;
}


SWIGINTERN VALUE
TradeRequestType_ADVISORIESMATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ADVISORIESMATCH));
  return _val;
}


SWIGINTERN VALUE
TradeRequestType_MATCHEDTRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_MATCHEDTRADES));
  return _val;
}


SWIGINTERN VALUE
TradeRequestType_UNMATCHEDTRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNMATCHEDTRADES));
  return _val;
}


SWIGINTERN VALUE
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
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
TradSesStatus_PRECLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRECLOSE));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_HALTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_HALTED));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_REQREJ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_REQREJ));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_REQUEST_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_REQUEST_REJECTED));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_OPEN));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_PREOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PREOPEN));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_PRE_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_OPEN));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_UNKNOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_UNKNOWN));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_PRE_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_CLOSE));
  return _val;
}


SWIGINTERN VALUE
TradSesStatus_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_CLOSED));
  return _val;
}


SWIGINTERN VALUE
PegPriceType_LAST_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_LAST_PEG));
  return _val;
}


SWIGINTERN VALUE
PegPriceType_PRIMARY_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PRIMARY_PEG));
  return _val;
}


SWIGINTERN VALUE
PegPriceType_OPENING_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_OPENING_PEG));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
PegPriceType_MARKET_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MARKET_PEG));
  return _val;
}


SWIGINTERN VALUE
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
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
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
StreamAsgnRejReason_UNKNOWN_CLIENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_CLIENT));
  return _val;
}


SWIGINTERN VALUE
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
StreamAsgnRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
ValuationMethod_PREMIUM_STYLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ValuationMethod_PREMIUM_STYLE);
  return _val;
}


SWIGINTERN VALUE
ValuationMethod_CDS_IN_DELIVERY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_IN_DELIVERY);
  return _val;
}


SWIGINTERN VALUE
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
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
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
TriggerType_NEXT_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerType_NEXT_AUCTION));
  return _val;
}


SWIGINTERN VALUE
TriggerType_PRICE_MOVEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerType_PRICE_MOVEMENT));
  return _val;
}


SWIGINTERN VALUE
TriggerType_PARTIAL_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerType_PARTIAL_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
PriceProtectionScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
PriceProtectionScope_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NONE));
  return _val;
}


SWIGINTERN VALUE
PriceProtectionScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
PriceProtectionScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
TradeReportRejectReason_SUCCESSFULDEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_SUCCESSFULDEFAULT));
  return _val;
}


SWIGINTERN VALUE
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
TradeReportRejectReason_SUCCESSFUL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_SUCCESSFUL));
  return _val;
}


SWIGINTERN VALUE
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
TradeReportRejectReason_UNKNOWN_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNKNOWN_INSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
TradeReportRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
TradeReportRejectReason_INVALIDTRADETYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALIDTRADETYPE));
  return _val;
}


SWIGINTERN VALUE
TradeReportRejectReason_UNKNOWNINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNKNOWNINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
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
TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES));
  return _val;
}


SWIGINTERN VALUE
TradeReportRejectReason_INVALIDPARTYINFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALIDPARTYINFORMATION));
  return _val;
}


SWIGINTERN VALUE
SecurityListType_NEWSPAPER_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_NEWSPAPER_LIST));
  return _val;
}


SWIGINTERN VALUE
SecurityListType_TRADING_LIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_TRADING_LIST));
  return _val;
}


SWIGINTERN VALUE
SecurityListType_INDUSTRY_CLASSIFICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_INDUSTRY_CLASSIFICATION));
  return _val;
}


SWIGINTERN VALUE
SecurityListType_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListType_MARKET));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_QUOTE_LOCKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_LOCKED));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_UNKNSYM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNSYM));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_EXCHCLSD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCHCLSD));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_DUPORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_DUPORD));
  return _val;
}


SWIGINTERN VALUE
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
QuoteRejectReason_INVALID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_PRICE));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_TOOLATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_TOOLATE));
  return _val;
}


SWIGINTERN VALUE
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
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
QuoteRejectReason_UNKNORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNORD));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_INVPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVPX));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_INVSPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVSPREAD));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_NOTAUTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_NOTAUTH));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
QuoteRejectReason_UNKNOWN_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_QUOTE));
  return _val;
}


SWIGINTERN VALUE
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
QuoteRejectReason_ORDEXLIM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_ORDEXLIM));
  return _val;
}


SWIGINTERN VALUE
QuoteRejectReason_DUPLICATE_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_DUPLICATE_QUOTE));
  return _val;
}


SWIGINTERN VALUE
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
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
PossResend_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossResend_NO));
  return _val;
}


SWIGINTERN VALUE
PossResend_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossResend_YES));
  return _val;
}


SWIGINTERN VALUE
QuantityType_SHARES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_SHARES));
  return _val;
}


SWIGINTERN VALUE
QuantityType_CURRENTFACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENTFACE));
  return _val;
}


SWIGINTERN VALUE
QuantityType_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_PAR));
  return _val;
}


SWIGINTERN VALUE
QuantityType_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_BONDS));
  return _val;
}


SWIGINTERN VALUE
QuantityType_ORIGINALFACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_ORIGINALFACE));
  return _val;
}


SWIGINTERN VALUE
QuantityType_CONTRACTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_CONTRACTS));
  return _val;
}


SWIGINTERN VALUE
QuantityType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_OTHER));
  return _val;
}


SWIGINTERN VALUE
QuantityType_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENCY));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
ImpliedMarketIndicator_NOT_IMPLIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_NOT_IMPLIED));
  return _val;
}


SWIGINTERN VALUE
ImpliedMarketIndicator_IMPLIED_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_OUT));
  return _val;
}


SWIGINTERN VALUE
ImpliedMarketIndicator_IMPLIED_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_IN));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestType_AUTOMATIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_AUTOMATIC));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestType_MAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_MAN));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestType_AUTO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_AUTO));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestType_MANUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_MANUAL));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestResult_INSTRUMENTUNAVAILABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INSTRUMENTUNAVAILABLE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
SecurityRequestResult_VALID_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_VALID_REQUEST));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestResult_VALIDREQ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_VALIDREQ));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestResult_NOINSTRUMENTSFOUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOINSTRUMENTSFOUND));
  return _val;
}


SWIGINTERN VALUE
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
SecurityRequestResult_NOTAUTHORIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOTAUTHORIZED));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestResult_NOTSUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOTSUPPORTED));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestResult_INVALIDREQ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INVALIDREQ));
  return _val;
}


SWIGINTERN VALUE
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
OrderRestrictions_ISSUER_HOLDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUER_HOLDING));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_NON_INDEXARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_INDEXARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_EXMRKTPART_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXMRKTPART));
  return _val;
}


SWIGINTERN VALUE
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
OrderRestrictions_NON_ALGORITHMIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_ALGORITHMIC));
  return _val;
}


SWIGINTERN VALUE
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
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
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
OrderRestrictions_PROGRAM_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_PROGRAM_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
OrderRestrictions_INDEXARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INDEXARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_ACTMMDERIV_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTMMDERIV));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_FORENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_FORENTITY));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_CROSS));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_PROGRAMTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_PROGRAMTRADE));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_RISKARB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_RISKARB));
  return _val;
}


SWIGINTERN VALUE
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
OrderRestrictions_FOREIGN_ENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_FOREIGN_ENTITY));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_COMPETINGMARKETMAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_COMPETINGMARKETMAKER));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_EXINTMRKTLINK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXINTMRKTLINK));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_INDEX_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INDEX_ARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
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
OrderRestrictions_ALGORITHMIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ALGORITHMIC));
  return _val;
}


SWIGINTERN VALUE
OrderRestrictions_ACTMM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTMM));
  return _val;
}


SWIGINTERN VALUE
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
OrderRestrictions_RISKLESS_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_RISKLESS_ARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
ListExecInstType_IMMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_IMMED));
  return _val;
}


SWIGINTERN VALUE
ListExecInstType_WAIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_WAIT));
  return _val;
}


SWIGINTERN VALUE
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
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
ListExecInstType_IMMEDIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_IMMEDIATE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
ListExecInstType_EXCHCIVBUYTOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHCIVBUYTOP));
  return _val;
}


SWIGINTERN VALUE
ListExecInstType_EXCHCIVBUYWD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHCIVBUYWD));
  return _val;
}


SWIGINTERN VALUE
ListExecInstType_EXCHCIVSELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHCIVSELL));
  return _val;
}


SWIGINTERN VALUE
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
DistribPaymentMethod_FED_WIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FED_WIRE));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_ACH_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_ACH_CREDIT));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_EUROCLEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_EUROCLEAR));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_TELEGRAPHICTRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_TELEGRAPHICTRANSFER));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_ACHCREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_ACHCREDIT));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_TELEGRAPHIC_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_FEDWIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FEDWIRE));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_CHEQUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CHEQUE));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_DIRECT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_DIRECT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_CREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CREST));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_BPAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_BPAY));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_CLEARSTREAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CLEARSTREAM));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_DIRECTCREDITBECSBACS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_DIRECTCREDITBECSBACS));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS));
  return _val;
}


SWIGINTERN VALUE
DistribPaymentMethod_NSCC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_NSCC));
  return _val;
}


SWIGINTERN VALUE
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
DistribPaymentMethod_REINVESTINFUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_REINVESTINFUND));
  return _val;
}


SWIGINTERN VALUE
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
OrderHandlingInstSource_NASD_OATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderHandlingInstSource_NASD_OATS));
  return _val;
}


SWIGINTERN VALUE
AffirmStatus_CONFIRMREJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_CONFIRMREJECTED));
  return _val;
}


SWIGINTERN VALUE
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
AffirmStatus_AFFIRMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_AFFIRMED));
  return _val;
}


SWIGINTERN VALUE
AffirmStatus_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
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
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
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
OrigCustOrderCapacity_ALL_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_ALL_OTHER));
  return _val;
}


SWIGINTERN VALUE
AllocMethod_GUARANTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocMethod_GUARANTOR));
  return _val;
}


SWIGINTERN VALUE
AllocMethod_AUTOMATIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocMethod_AUTOMATIC));
  return _val;
}


SWIGINTERN VALUE
AllocMethod_MANUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocMethod_MANUAL));
  return _val;
}


SWIGINTERN VALUE
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
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
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
MassCancelResponse_CXLORDERSSECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSSECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
MassCancelResponse_CXLORDERSUNDERLYINGSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSUNDERLYINGSECURITY));
  return _val;
}


SWIGINTERN VALUE
MassCancelResponse_CXLORDERSTRDSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSTRDSESSION));
  return _val;
}


SWIGINTERN VALUE
MassCancelResponse_CXLALLORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLALLORDERS));
  return _val;
}


SWIGINTERN VALUE
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
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
MassCancelResponse_CXLREQREJ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLREQREJ));
  return _val;
}


SWIGINTERN VALUE
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
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
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
MassCancelResponse_CXLORDERSSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSSECURITY));
  return _val;
}


SWIGINTERN VALUE
MassCancelResponse_CXLORDERSPRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSPRODUCT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
MassCancelResponse_CXLORDERSCFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CXLORDERSCFICODE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
SymbolSfx_EUCPLUMPSUMINTEREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SymbolSfx_EUCPLUMPSUMINTEREST);
  return _val;
}


SWIGINTERN VALUE
SymbolSfx_WHENISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SymbolSfx_WHENISSUED);
  return _val;
}


SWIGINTERN VALUE
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
ExDestinationIDSource_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
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
ExDestinationIDSource_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_BIC));
  return _val;
}


SWIGINTERN VALUE
ExDestinationIDSource_MIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_MIC));
  return _val;
}


SWIGINTERN VALUE
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
SecurityListRequestType_ALLSECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_ALLSECURITIES));
  return _val;
}


SWIGINTERN VALUE
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
SecurityListRequestType_SECURITYTYPECFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SECURITYTYPECFICODE));
  return _val;
}


SWIGINTERN VALUE
SecurityListRequestType_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
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
SecurityListRequestType_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
SecurityListRequestType_ALL_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_ALL_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
SecurityListRequestType_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_FORWARDCOLLATERALDEMAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_FORWARDCOLLATERALDEMAND));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_ADVERSETAXEVENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_ADVERSETAXEVENT));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_MARGINDEFICIENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGINDEFICIENCY));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_TIME_WARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TIME_WARNING));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_TIMEWARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TIMEWARNING));
  return _val;
}


SWIGINTERN VALUE
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
CollAsgnReason_MARGINEXCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGINEXCESS));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_MARGIN_DEFICIENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_DEFICIENCY));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_SCHEDULED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_SCHEDULED));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_INITIAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_INITIAL));
  return _val;
}


SWIGINTERN VALUE
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
CollAsgnReason_EVENTOFDEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_EVENTOFDEFAULT));
  return _val;
}


SWIGINTERN VALUE
CollAsgnReason_MARGIN_EXCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_EXCESS));
  return _val;
}


SWIGINTERN VALUE
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
SettlPriceType_FINAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_FINAL));
  return _val;
}


SWIGINTERN VALUE
SettlPriceType_THEORETICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_THEORETICAL));
  return _val;
}


SWIGINTERN VALUE
DealingCapacity_RISKLESS_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_RISKLESS_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
DealingCapacity_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
DealingCapacity_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_AGENT));
  return _val;
}


SWIGINTERN VALUE
RateSourceType_SECONDARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSourceType_SECONDARY));
  return _val;
}


SWIGINTERN VALUE
RateSourceType_PRIMARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSourceType_PRIMARY));
  return _val;
}


SWIGINTERN VALUE
AggregatedBook_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_NO));
  return _val;
}


SWIGINTERN VALUE
AggregatedBook_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_YES));
  return _val;
}


SWIGINTERN VALUE
PosQtyStatus_SUBMITTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_SUBMITTED));
  return _val;
}


SWIGINTERN VALUE
PosQtyStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
PosQtyStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
MsgType_TradingSessionStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatusRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_ListStatus_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListStatus);
  return _val;
}


SWIGINTERN VALUE
MsgType_Email_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Email);
  return _val;
}


SWIGINTERN VALUE
MsgType_ListExecute_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListExecute);
  return _val;
}


SWIGINTERN VALUE
MsgType_Confirmation_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Confirmation);
  return _val;
}


SWIGINTERN VALUE
MsgType_NewOrderMultileg_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderMultileg);
  return _val;
}


SWIGINTERN VALUE
MsgType_IndicationofInterest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_IndicationofInterest);
  return _val;
}


SWIGINTERN VALUE
MsgType_MarketDataIncrementalRefresh_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataIncrementalRefresh);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradeCaptureReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_RequestForPositionsAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RequestForPositionsAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_StreamAssignmentRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityListRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityListRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_CollateralReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_PositionMaintenanceReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_PositionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PositionReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_StreamAssignmentReportACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReportACK);
  return _val;
}


SWIGINTERN VALUE
MsgType_UserRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_UserRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_PositionMaintenanceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_NetworkCounterpartySystemStatusResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusResponse);
  return _val;
}


SWIGINTERN VALUE
MsgType_NewOrderCross_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderCross);
  return _val;
}


SWIGINTERN VALUE
MsgType_AdjustedPositionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AdjustedPositionReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_Logon_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Logon);
  return _val;
}


SWIGINTERN VALUE
MsgType_IOI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_IOI);
  return _val;
}


SWIGINTERN VALUE
MsgType_ListStrikePrice_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListStrikePrice);
  return _val;
}


SWIGINTERN VALUE
MsgType_BidRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_BidRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradingSessionStatus_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatus);
  return _val;
}


SWIGINTERN VALUE
MsgType_RegistrationInstructionsResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructionsResponse);
  return _val;
}


SWIGINTERN VALUE
MsgType_Advertisement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Advertisement);
  return _val;
}


SWIGINTERN VALUE
MsgType_MassQuote_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MassQuote);
  return _val;
}


SWIGINTERN VALUE
MsgType_Logout_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Logout);
  return _val;
}


SWIGINTERN VALUE
MsgType_AllocationReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityDefinitionUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionUpdateReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_ListStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListStatusRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_BusinessMessageReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_BusinessMessageReject);
  return _val;
}


SWIGINTERN VALUE
MsgType_ConfirmationAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ConfirmationAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_TestRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TestRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityList);
  return _val;
}


SWIGINTERN VALUE
MsgType_ListCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ListCancelRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_News_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_News);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradingSessionListUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListUpdateReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_Heartbeat_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Heartbeat);
  return _val;
}


SWIGINTERN VALUE
MsgType_QuoteAcknowledgement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteAcknowledgement);
  return _val;
}


SWIGINTERN VALUE
MsgType_AllocationReportAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationReportAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_ConfirmationRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ConfirmationRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderMassActionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_CollateralInquiry_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiry);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityTypeRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityTypeRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_NewOrderList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderList);
  return _val;
}


SWIGINTERN VALUE
MsgType_ExecutionAcknowledgement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ExecutionAcknowledgement);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradingSessionListRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityTypes_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityTypes);
  return _val;
}


SWIGINTERN VALUE
MsgType_MarketDefinition_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDefinition);
  return _val;
}


SWIGINTERN VALUE
MsgType_SequenceReset_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SequenceReset);
  return _val;
}


SWIGINTERN VALUE
MsgType_CollateralResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralResponse);
  return _val;
}


SWIGINTERN VALUE
MsgType_MassQuoteAcknowledgement_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MassQuoteAcknowledgement);
  return _val;
}


SWIGINTERN VALUE
MsgType_QuoteResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteResponse);
  return _val;
}


SWIGINTERN VALUE
MsgType_QuoteStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_QuoteCancel_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteCancel);
  return _val;
}


SWIGINTERN VALUE
MsgType_ContraryIntentionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ContraryIntentionReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_PartyDetailsListReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsListReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_PartyDetailsListRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_PartyDetailsListRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_CrossOrderCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_NewOrderSingle_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NewOrderSingle);
  return _val;
}


SWIGINTERN VALUE
MsgType_DerivativeSecurityListRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_CollateralRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_UserNotification_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_UserNotification);
  return _val;
}


SWIGINTERN VALUE
MsgType_UserResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_UserResponse);
  return _val;
}


SWIGINTERN VALUE
MsgType_DontKnowTrade_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DontKnowTrade);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradeCaptureReportAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_ApplicationMessageRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_MultilegOrderCancelReplace_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplace);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderCancelReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReject);
  return _val;
}


SWIGINTERN VALUE
MsgType_ExecutionReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ExecutionReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_QuoteStatusReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_ResendRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ResendRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_Quote_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Quote);
  return _val;
}


SWIGINTERN VALUE
MsgType_SettlementInstructionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructionRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityListUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityListUpdateReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_AllocationInstructionAlert_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAlert);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradeCaptureReportRequestAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequestAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_AllocationInstruction_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationInstruction);
  return _val;
}


SWIGINTERN VALUE
MsgType_Allocation_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Allocation);
  return _val;
}


SWIGINTERN VALUE
MsgType_ApplicationMessageReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_RegistrationInstructions_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructions);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityDefinition_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinition);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityDefinitionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityStatus_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityStatus);
  return _val;
}


SWIGINTERN VALUE
MsgType_DerivativeSecurityList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityList);
  return _val;
}


SWIGINTERN VALUE
MsgType_NetworkCounterpartySystemStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_MarketDefinitionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_Reject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_Reject);
  return _val;
}


SWIGINTERN VALUE
MsgType_DerivativeSecurityListUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListUpdateReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_QuoteRequestReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteRequestReject);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderMassStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassStatusRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_ApplicationMessageRequestAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequestAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_SecurityStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SecurityStatusRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_AllocationACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationACK);
  return _val;
}


SWIGINTERN VALUE
MsgType_MarketDefinitionUpdateReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionUpdateReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_CrossOrderCancelReplaceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelReplaceRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderMassCancelReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_AssignmentReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AssignmentReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_BidResponse_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_BidResponse);
  return _val;
}


SWIGINTERN VALUE
MsgType_RequestForPositions_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RequestForPositions);
  return _val;
}


SWIGINTERN VALUE
MsgType_SettlementObligationReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SettlementObligationReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderMassCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradingSessionList_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradingSessionList);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderStatusRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderStatusRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_CollateralAssignment_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralAssignment);
  return _val;
}


SWIGINTERN VALUE
MsgType_StreamAssignmentReport_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReport);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderMassActionRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_AllocationAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_QuoteRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_QuoteRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_CollateralInquiryAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiryAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_MarketDataSnapshotFullRefresh_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataSnapshotFullRefresh);
  return _val;
}


SWIGINTERN VALUE
MsgType_SettlementInstructions_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructions);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderCancelReplaceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReplaceRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_TradeCaptureReportRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_RFQRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_RFQRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_OrderCancelRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_OrderCancelRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_MultilegOrderCancelReplaceRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplaceRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_AllocationInstructionAck_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAck);
  return _val;
}


SWIGINTERN VALUE
MsgType_MarketDataRequest_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequest);
  return _val;
}


SWIGINTERN VALUE
MsgType_MarketDataRequestReject_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequestReject);
  return _val;
}


SWIGINTERN VALUE
MultiLegReportingType_SINGLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_SINGLE));
  return _val;
}


SWIGINTERN VALUE
MultiLegReportingType_MULTILEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_MULTILEG));
  return _val;
}


SWIGINTERN VALUE
MultiLegReportingType_SINGLE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_SINGLE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
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
MultiLegReportingType_INDIVLEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_INDIVLEG));
  return _val;
}


SWIGINTERN VALUE
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
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
IDSource_EXCHANGE_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_EXCHANGE_SYMBOL);
  return _val;
}


SWIGINTERN VALUE
IDSource_RIC_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_RIC_CODE);
  return _val;
}


SWIGINTERN VALUE
IDSource_ISO_CURRENCY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_ISO_CURRENCY_CODE);
  return _val;
}


SWIGINTERN VALUE
IDSource_ISIN_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_ISIN_NUMBER);
  return _val;
}


SWIGINTERN VALUE
IDSource_SEDOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_SEDOL);
  return _val;
}


SWIGINTERN VALUE
IDSource_ISO_COUNTRY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_ISO_COUNTRY_CODE);
  return _val;
}


SWIGINTERN VALUE
IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
IDSource_QUIK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_QUIK);
  return _val;
}


SWIGINTERN VALUE
IDSource_CUSIP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IDSource_CUSIP);
  return _val;
}


SWIGINTERN VALUE
OrdStatus_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_NEW));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_PENDINGNEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDINGNEW));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_PENDING_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_CANCEL));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_PARTIAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PARTIAL));
  return _val;
}


SWIGINTERN VALUE
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
OrdStatus_PENDING_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_NEW));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_STOPPED));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_FILLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_FILLED));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_PENDING_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_REPLACE));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_CANCELED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CANCELED));
  return _val;
}


SWIGINTERN VALUE
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
OrdStatus_SUSPENDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_SUSPENDED));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_DONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_DONE));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_PARTIALLY_FILLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PARTIALLY_FILLED));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_REPLACED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REPLACED));
  return _val;
}


SWIGINTERN VALUE
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
OrdStatus_ACCEPTBIDDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_ACCEPTBIDDING));
  return _val;
}


SWIGINTERN VALUE
OrdStatus_PENDINGREP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDINGREP));
  return _val;
}


SWIGINTERN VALUE
CustomerOrFirm_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_FIRM));
  return _val;
}


SWIGINTERN VALUE
CustomerOrFirm_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
AdjustmentType_DELTA_MINUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_MINUS));
  return _val;
}


SWIGINTERN VALUE
AdjustmentType_DELTAPLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTAPLUS));
  return _val;
}


SWIGINTERN VALUE
AdjustmentType_DELTA_PLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_PLUS));
  return _val;
}


SWIGINTERN VALUE
AdjustmentType_DELTAMINUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTAMINUS));
  return _val;
}


SWIGINTERN VALUE
AdjustmentType_FINAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_FINAL));
  return _val;
}


SWIGINTERN VALUE
AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION));
  return _val;
}


SWIGINTERN VALUE
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
AsOfIndicator_TRUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_TRUE));
  return _val;
}


SWIGINTERN VALUE
AsOfIndicator_FALSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_FALSE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
MassActionScope_ALL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
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
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
VenueType_PIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::VenueType_PIT));
  return _val;
}


SWIGINTERN VALUE
VenueType_EX_PIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::VenueType_EX_PIT));
  return _val;
}


SWIGINTERN VALUE
VenueType_ELECTRONIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::VenueType_ELECTRONIC));
  return _val;
}


SWIGINTERN VALUE
MassActionType_CANCEL_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionType_CANCEL_ORDERS));
  return _val;
}


SWIGINTERN VALUE
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
MassActionType_SUSPEND_ORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionType_SUSPEND_ORDERS));
  return _val;
}


SWIGINTERN VALUE
PosMaintResult_SUCCESSFULCOMPLETION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_SUCCESSFULCOMPLETION));
  return _val;
}


SWIGINTERN VALUE
PosMaintResult_SUCCESSFUL_COMPLETION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_SUCCESSFUL_COMPLETION));
  return _val;
}


SWIGINTERN VALUE
PosMaintResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
PosMaintResult_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_REJECTED));
  return _val;
}


SWIGINTERN VALUE
IOIShares_MEDIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIShares_MEDIUM);
  return _val;
}


SWIGINTERN VALUE
IOIShares_LARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIShares_LARGE);
  return _val;
}


SWIGINTERN VALUE
IOIShares_SMALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIShares_SMALL);
  return _val;
}


SWIGINTERN VALUE
PegOffsetType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE));
  return _val;
}


SWIGINTERN VALUE
PegOffsetType_BASISPOINTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_BASISPOINTS));
  return _val;
}


SWIGINTERN VALUE
PegOffsetType_PRICE_TIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE_TIER));
  return _val;
}


SWIGINTERN VALUE
PegOffsetType_TICKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_TICKS));
  return _val;
}


SWIGINTERN VALUE
PegOffsetType_PRICETIERLEVEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICETIERLEVEL));
  return _val;
}


SWIGINTERN VALUE
PegOffsetType_BASIS_POINTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_BASIS_POINTS));
  return _val;
}


SWIGINTERN VALUE
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
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
MassCancelRejectReason_INVALIDSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDSECURITY));
  return _val;
}


SWIGINTERN VALUE
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
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
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
MassCancelRejectReason_INVALIDPRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDPRODUCT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
MassCancelRejectReason_INVALIDUNDERLYING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDUNDERLYING));
  return _val;
}


SWIGINTERN VALUE
MassCancelRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
MassCancelRejectReason_INVALIDCFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDCFICODE));
  return _val;
}


SWIGINTERN VALUE
MassCancelRejectReason_INVALIDSECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDSECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
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
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
MassCancelRejectReason_INVALIDTRDSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALIDTRDSESSION));
  return _val;
}


SWIGINTERN VALUE
MassCancelRejectReason_MASSCXLNOTSUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_MASSCXLNOTSUPPORTED));
  return _val;
}


SWIGINTERN VALUE
ResponseTransportType_OUTOFBAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_OUTOFBAND));
  return _val;
}


SWIGINTERN VALUE
ResponseTransportType_INBAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_INBAND));
  return _val;
}


SWIGINTERN VALUE
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
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
TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
TradSesStatusRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_EXECUTION_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_EXECUTION_TIME));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_BROKEREXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKEREXECUTION));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_BROKERRECEIPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKERRECEIPT));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_TIMEIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIMEIN));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_TIME_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_IN));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_TIMEOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIMEOUT));
  return _val;
}


SWIGINTERN VALUE
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
TrdRegTimestampType_BROKER_RECEIPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_RECEIPT));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_DESK_RECEIPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_DESK_RECEIPT));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_EXECUTIONTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_EXECUTIONTIME));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_BROKER_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
TrdRegTimestampType_TIME_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_OUT));
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX50SP1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP1);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX27_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX27);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX50SP2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP2);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX50_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX50);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX40_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX40);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX41_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX41);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX30_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX30);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX42_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX42);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX43_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX43);
  return _val;
}


SWIGINTERN VALUE
ApplVerID_FIX44_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ApplVerID_FIX44);
  return _val;
}


SWIGINTERN VALUE
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
HandlInst_AUTOEXECPUB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOEXECPUB));
  return _val;
}


SWIGINTERN VALUE
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
HandlInst_AUTOEXECPRIV_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOEXECPRIV));
  return _val;
}


SWIGINTERN VALUE
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
HandlInst_MANUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HandlInst_MANUAL));
  return _val;
}


SWIGINTERN VALUE
TradingSessionSubID_POST_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_POST_TRADING);
  return _val;
}


SWIGINTERN VALUE
TradingSessionSubID_INTRADAY_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_INTRADAY_AUCTION);
  return _val;
}


SWIGINTERN VALUE
TradingSessionSubID_PRE_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_PRE_TRADING);
  return _val;
}


SWIGINTERN VALUE
TradingSessionSubID_QUIESCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_QUIESCENT);
  return _val;
}


SWIGINTERN VALUE
TradingSessionSubID_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_3);
  return _val;
}


SWIGINTERN VALUE
TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_OPENING_OR_OPENING_AUCTION);
  return _val;
}


SWIGINTERN VALUE
TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION);
  return _val;
}


SWIGINTERN VALUE
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
MDEntryType_OPEN_INTEREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPEN_INTEREST));
  return _val;
}


SWIGINTERN VALUE
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
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
MDEntryType_INDEXVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_INDEXVALUE));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_OPENINTEREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENINTEREST));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CLOSING_PRICE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
MDEntryType_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_FIXING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_FIXING_PRICE));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_CASH_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CASH_RATE));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_CLOSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CLOSING));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_OPENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENING));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_OPENING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENING_PRICE));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_TRADINGHIGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADINGHIGH));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_TRADEVOLUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADEVOLUME));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
MDEntryType_EMPTY_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EMPTY_BOOK));
  return _val;
}


SWIGINTERN VALUE
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
MDEntryType_BID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_BID));
  return _val;
}


SWIGINTERN VALUE
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
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
MDEntryType_EARLY_PRICES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EARLY_PRICES));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_TRADINGLOW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADINGLOW));
  return _val;
}


SWIGINTERN VALUE
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
MDEntryType_INDEX_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_INDEX_VALUE));
  return _val;
}


SWIGINTERN VALUE
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
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
MDEntryType_MID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MID_PRICE));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_SETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLEMENT));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_RECOVERY_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE));
  return _val;
}


SWIGINTERN VALUE
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
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
MDEntryType_TRADE_VOLUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE_VOLUME));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_MARGIN_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MARGIN_RATE));
  return _val;
}


SWIGINTERN VALUE
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
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
MDEntryType_TRADINGVWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADINGVWAP));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_SETTLEMENT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLEMENT_PRICE));
  return _val;
}


SWIGINTERN VALUE
MDEntryType_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OFFER));
  return _val;
}


SWIGINTERN VALUE
PegMoveType_FLOATING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FLOATING));
  return _val;
}


SWIGINTERN VALUE
PegMoveType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FIXED));
  return _val;
}


SWIGINTERN VALUE
AvgPxIndicator_NOAVERAGEPRICING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_NOAVERAGEPRICING));
  return _val;
}


SWIGINTERN VALUE
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
AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP));
  return _val;
}


SWIGINTERN VALUE
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
AvgPxIndicator_TRADEAVERAGEPRICEGROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_TRADEAVERAGEPRICEGROUP));
  return _val;
}


SWIGINTERN VALUE
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
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
CancellationRights_NO_M_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_M));
  return _val;
}


SWIGINTERN VALUE
CancellationRights_NO_N_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_N));
  return _val;
}


SWIGINTERN VALUE
CancellationRights_NOINSTIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NOINSTIT));
  return _val;
}


SWIGINTERN VALUE
CancellationRights_NO_INSTITUTIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_INSTITUTIONAL));
  return _val;
}


SWIGINTERN VALUE
CancellationRights_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_YES));
  return _val;
}


SWIGINTERN VALUE
CancellationRights_NO_O_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_O));
  return _val;
}


SWIGINTERN VALUE
CancellationRights_NOEXECONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NOEXECONLY));
  return _val;
}


SWIGINTERN VALUE
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
CancellationRights_NOWAIVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NOWAIVER));
  return _val;
}


SWIGINTERN VALUE
ExecPriceType_CREATIONPRICEADJAMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATIONPRICEADJAMT));
  return _val;
}


SWIGINTERN VALUE
ExecPriceType_CREATION_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE));
  return _val;
}


SWIGINTERN VALUE
ExecPriceType_CREATIONPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATIONPRICE));
  return _val;
}


SWIGINTERN VALUE
ExecPriceType_SINGLEPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_SINGLEPRICE));
  return _val;
}


SWIGINTERN VALUE
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
ExecPriceType_OFFERPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFERPRICE));
  return _val;
}


SWIGINTERN VALUE
ExecPriceType_BIDPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_BIDPRICE));
  return _val;
}


SWIGINTERN VALUE
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
ExecPriceType_CREATIONPRICEADJPCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATIONPRICEADJPCT));
  return _val;
}


SWIGINTERN VALUE
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
ExecPriceType_OFFERPRICEMINUSADJAMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFERPRICEMINUSADJAMT));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecPriceType_OFFERPRICEMINUSADJPCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFERPRICEMINUSADJPCT));
  return _val;
}


SWIGINTERN VALUE
ExecPriceType_BID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_BID_PRICE));
  return _val;
}


SWIGINTERN VALUE
ExecPriceType_SINGLE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_SINGLE_PRICE));
  return _val;
}


SWIGINTERN VALUE
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
ExecPriceType_OFFER_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE));
  return _val;
}


SWIGINTERN VALUE
AllocSettlInstType_PHONEFORINSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_PHONEFORINSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
AllocSettlInstType_SSIDBIDSPROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_SSIDBIDSPROVIDED));
  return _val;
}


SWIGINTERN VALUE
AllocSettlInstType_FULLDETAILSPROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_FULLDETAILSPROVIDED));
  return _val;
}


SWIGINTERN VALUE
AllocSettlInstType_USEDEFAULTINSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_USEDEFAULTINSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED));
  return _val;
}


SWIGINTERN VALUE
StatsType_AVERAGE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_AVERAGE_PRICE));
  return _val;
}


SWIGINTERN VALUE
StatsType_HIGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_HIGH));
  return _val;
}


SWIGINTERN VALUE
StatsType_EXCHANGE_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_EXCHANGE_LAST));
  return _val;
}


SWIGINTERN VALUE
StatsType_TURNOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatsType_TURNOVER));
  return _val;
}


SWIGINTERN VALUE
TradSesMode_SIMULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMode_SIMULATED));
  return _val;
}


SWIGINTERN VALUE
TradSesMode_PRODUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMode_PRODUCTION));
  return _val;
}


SWIGINTERN VALUE
TradSesMode_TESTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMode_TESTING));
  return _val;
}


SWIGINTERN VALUE
SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INSTITUTIONS_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
SettlInstSource_BROKERS_INSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_BROKERS_INSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
SettlInstSource_INVESTORCIV_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INVESTORCIV));
  return _val;
}


SWIGINTERN VALUE
SettlInstSource_INVESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INVESTOR));
  return _val;
}


SWIGINTERN VALUE
SettlInstSource_INSTINSTR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INSTINSTR));
  return _val;
}


SWIGINTERN VALUE
SettlInstSource_BROKERINSTR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_BROKERINSTR));
  return _val;
}


SWIGINTERN VALUE
ExpType_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
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
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
ExpType_CONTRARY_INTENTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_CONTRARY_INTENTION));
  return _val;
}


SWIGINTERN VALUE
ExpType_AUTO_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpType_AUTO_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
SettlInstTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
SettlInstTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
SettlInstTransType_RESTATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_RESTATE));
  return _val;
}


SWIGINTERN VALUE
SettlInstTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED));
  return _val;
}


SWIGINTERN VALUE
TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
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
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
TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED));
  return _val;
}


SWIGINTERN VALUE
TradeRequestResult_INVALIDPARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDPARTIES));
  return _val;
}


SWIGINTERN VALUE
TradeRequestResult_INVALIDDESTINATIONREQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDDESTINATIONREQUESTED));
  return _val;
}


SWIGINTERN VALUE
TradeRequestResult_SUCCESSFUL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_SUCCESSFUL));
  return _val;
}


SWIGINTERN VALUE
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
TradeRequestResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
TradeRequestResult_INVALID_PARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_PARTIES));
  return _val;
}


SWIGINTERN VALUE
TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST));
  return _val;
}


SWIGINTERN VALUE
TradeRequestResult_NOT_AUTHORIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_NOT_AUTHORIZED));
  return _val;
}


SWIGINTERN VALUE
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
TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED));
  return _val;
}


SWIGINTERN VALUE
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
TestMessageIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
TestMessageIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
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
ExpirationCycle_EXPIREONTRADINGSESSIONOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIREONTRADINGSESSIONOPEN));
  return _val;
}


SWIGINTERN VALUE
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
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
ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE));
  return _val;
}


SWIGINTERN VALUE
AllocCancReplaceReason_ORIGINALDETAILSINCORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_ORIGINALDETAILSINCORRECT));
  return _val;
}


SWIGINTERN VALUE
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
AllocCancReplaceReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS));
  return _val;
}


SWIGINTERN VALUE
CxlRejReason_DUPLICATE_CLORDID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPLICATE_CLORDID));
  return _val;
}


SWIGINTERN VALUE
CxlRejReason_UNABLETOPROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNABLETOPROCESS));
  return _val;
}


SWIGINTERN VALUE
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
CxlRejReason_DUPCLORDID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPCLORDID));
  return _val;
}


SWIGINTERN VALUE
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
CxlRejReason_UNKNOWN_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNKNOWN_ORDER));
  return _val;
}


SWIGINTERN VALUE
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
CxlRejReason_TOOLATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_TOOLATE));
  return _val;
}


SWIGINTERN VALUE
CxlRejReason_ORIGORDMODTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIME));
  return _val;
}


SWIGINTERN VALUE
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
CxlRejReason_BROKEROPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKEROPT));
  return _val;
}


SWIGINTERN VALUE
CxlRejReason_ALREADYPENDINGCXL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ALREADYPENDINGCXL));
  return _val;
}


SWIGINTERN VALUE
CxlRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
CxlRejReason_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER));
  return _val;
}


SWIGINTERN VALUE
CxlRejReason_BROKER_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER_OPTION));
  return _val;
}


SWIGINTERN VALUE
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
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
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
CxlRejReason_ORIGORDMODTIMEMISMATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIMEMISMATCH));
  return _val;
}


SWIGINTERN VALUE
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
CxlRejReason_UNKNOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNKNOWN));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
DKReason_UNKNOWNSYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_UNKNOWNSYMBOL));
  return _val;
}


SWIGINTERN VALUE
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
DKReason_QUANTITYEXCEEDSORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_QUANTITYEXCEEDSORDER));
  return _val;
}


SWIGINTERN VALUE
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
DKReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
DKReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
DKReason_WRONGSIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_WRONGSIDE));
  return _val;
}


SWIGINTERN VALUE
DKReason_CALCULATIONDIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_CALCULATIONDIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
DKReason_PRICEEXCEEDSLIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_PRICEEXCEEDSLIMIT));
  return _val;
}


SWIGINTERN VALUE
DKReason_WRONG_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_WRONG_SIDE));
  return _val;
}


SWIGINTERN VALUE
DKReason_CALCULATION_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_CALCULATION_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
DKReason_NOMATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DKReason_NOMATCH));
  return _val;
}


SWIGINTERN VALUE
PositionEffect_DEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_DEFAULT));
  return _val;
}


SWIGINTERN VALUE
PositionEffect_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE));
  return _val;
}


SWIGINTERN VALUE
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
PositionEffect_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_OPEN));
  return _val;
}


SWIGINTERN VALUE
PositionEffect_FIFO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_FIFO));
  return _val;
}


SWIGINTERN VALUE
PositionEffect_ROLLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PositionEffect_ROLLED));
  return _val;
}


SWIGINTERN VALUE
TriggerAction_ACTIVATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerAction_ACTIVATE));
  return _val;
}


SWIGINTERN VALUE
TriggerAction_MODIFY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerAction_MODIFY));
  return _val;
}


SWIGINTERN VALUE
TriggerAction_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerAction_CANCEL));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_BILATERALNETTINGONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_BILATERALNETTINGONLY));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_SPECIALTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SPECIALTRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
ClearingInstruction_EXCLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLEARING));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_MULTILATERAL_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MULTILATERAL_NETTING));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
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
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
ClearingInstruction_CUSTOMER_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CUSTOMER_TRADE));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_EX_CLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EX_CLEARING));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_MULTILATERALNETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MULTILATERALNETTING));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_PROCESSNORMALLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_PROCESSNORMALLY));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_EXCLUDEFROMALLNETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDEFROMALLNETTING));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_SELFCLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SELFCLEARING));
  return _val;
}


SWIGINTERN VALUE
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
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
ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_CUSTOMERTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CUSTOMERTRADE));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_PROCESS_NORMALLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_PROCESS_NORMALLY));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_SPECIAL_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SPECIAL_TRADE));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_MANUAL_MODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MANUAL_MODE));
  return _val;
}


SWIGINTERN VALUE
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
ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED));
  return _val;
}


SWIGINTERN VALUE
ClearingInstruction_SELF_CLEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SELF_CLEARING));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_SESSION_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_SESSION_OPEN));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_EXPECTED_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_EXPECTED_ENTRY));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_THEORETICALPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_THEORETICALPRICE));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_DAILY_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DAILY_OPEN));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_DAILYOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DAILYOPEN));
  return _val;
}


SWIGINTERN VALUE
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
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
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
OpenCloseSettlFlag_DELIVERYSETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DELIVERYSETTLEMENT));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_SESSIONOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_SESSIONOPEN));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettlFlag_EXPECTEDENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_EXPECTEDENTRY));
  return _val;
}


SWIGINTERN VALUE
DiscretionMoveType_FLOATING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FLOATING));
  return _val;
}


SWIGINTERN VALUE
DiscretionMoveType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FIXED));
  return _val;
}


SWIGINTERN VALUE
MDUpdateType_INCREMENTAL_REFRESH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_INCREMENTAL_REFRESH));
  return _val;
}


SWIGINTERN VALUE
MDUpdateType_FULL_REFRESH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_FULL_REFRESH));
  return _val;
}


SWIGINTERN VALUE
MDUpdateType_FULL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_FULL));
  return _val;
}


SWIGINTERN VALUE
MDUpdateType_INCREMENTAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_INCREMENTAL));
  return _val;
}


SWIGINTERN VALUE
TickDirection_MINUS_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_MINUS_TICK));
  return _val;
}


SWIGINTERN VALUE
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
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
TickDirection_PLUS_TICK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_PLUS_TICK));
  return _val;
}


SWIGINTERN VALUE
TickDirection_PLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_PLUS));
  return _val;
}


SWIGINTERN VALUE
TickDirection_ZEROPLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZEROPLUS));
  return _val;
}


SWIGINTERN VALUE
TickDirection_MINUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_MINUS));
  return _val;
}


SWIGINTERN VALUE
TickDirection_ZEROMINUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZEROMINUS));
  return _val;
}


SWIGINTERN VALUE
YieldType_MARK_TO_MARKET_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MARK_TO_MARKET_YIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_YIELD_TO_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_MATURITY);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDTOTENDERDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTOTENDERDATE);
  return _val;
}


SWIGINTERN VALUE
YieldType_PREVIOUS_CLOSE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PREVIOUS_CLOSE_YIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_YIELDTOSHORTESTAVERAGELIFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTOSHORTESTAVERAGELIFE);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELD_AT_ISSUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_AT_ISSUE);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELD_TO_NEXT_REFUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_REFUND);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDATISSUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDATISSUE);
  return _val;
}


SWIGINTERN VALUE
YieldType_CLOSINGYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_GVNTEQUIVALENTYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_GVNTEQUIVALENTYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_ANNUALYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_ANNUALYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_AFTER_TAX_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_AFTER_TAX_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_GVNT_EQUIVALENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_GVNT_EQUIVALENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDCHANGESINCECLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDCHANGESINCECLOSE);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDTOMATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTOMATURITY);
  return _val;
}


SWIGINTERN VALUE
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
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
YieldType_SEMI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SEMI);
  return _val;
}


SWIGINTERN VALUE
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
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
YieldType_YIELD_TO_NEXT_CALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_CALL);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELD_CHANGE_SINCE_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_CHANGE_SINCE_CLOSE);
  return _val;
}


SWIGINTERN VALUE
YieldType_PROCEEDS_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PROCEEDS_YIELD);
  return _val;
}


SWIGINTERN VALUE
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
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
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
YieldType_CURRENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CURRENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_SIMPLEYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SIMPLEYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_TRUEGROSSYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUEGROSSYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_COMPOUND_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_COMPOUND_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_CLOSINGYIELDMOSTRECENTYEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELDMOSTRECENTYEAR);
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
YieldType_YIELD_TO_AVG_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVG_MATURITY);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELD_TO_TENDER_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_TENDER_DATE);
  return _val;
}


SWIGINTERN VALUE
YieldType_PROCEEDSYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PROCEEDSYIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_ANNUAL_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_ANNUAL_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELD_TO_WORST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_WORST);
  return _val;
}


SWIGINTERN VALUE
YieldType_BOOK_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_BOOK_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELD_TO_NEXT_PUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_PUT);
  return _val;
}


SWIGINTERN VALUE
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
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
YieldType_OPENAVERAGEYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_OPENAVERAGEYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_TRUE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUE_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_TAX_EQUIVALENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TAX_EQUIVALENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_TRUE_GROSS_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUE_GROSS_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_INVERSE_FLOATER_BOND_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_INVERSE_FLOATER_BOND_YIELD);
  return _val;
}


SWIGINTERN VALUE
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
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
YieldType_AFTERTAXYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_AFTERTAXYIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_YIELDTOWORSTCONVENTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTOWORSTCONVENTION);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_COMPOUNDYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_COMPOUNDYIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_YIELD_TO_LONGEST_AVERAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE);
  return _val;
}


SWIGINTERN VALUE
YieldType_PREVIOUSCLOSEYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_PREVIOUSCLOSEYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_CLOSINGYIELDMOSTRECENTMONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELDMOSTRECENTMONTH);
  return _val;
}


SWIGINTERN VALUE
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
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
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
YieldType_YIELD_TO_SHORTEST_AVERAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE);
  return _val;
}


SWIGINTERN VALUE
YieldType_TAXEQUIVALENTYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TAXEQUIVALENTYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_MOSTRECENTCLOSINGYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MOSTRECENTCLOSINGYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_MARKTOMARKETYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MARKTOMARKETYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_CURRENTYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CURRENTYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_OPEN_AVERAGE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_OPEN_AVERAGE_YIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_WITH_INFLATION_ASSUMPTION);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDTONEXTREFUNDSINKING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTONEXTREFUNDSINKING);
  return _val;
}


SWIGINTERN VALUE
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
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
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
YieldType_SIMPLE_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SIMPLE_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELD_TO_AVERAGE_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_MATURITY);
  return _val;
}


SWIGINTERN VALUE
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
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
YieldType_YIELDTOAVGMATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTOAVGMATURITY);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDTOLONGESTAVERAGELIFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTOLONGESTAVERAGELIFE);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_SEMI_ANNUAL_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_SEMI_ANNUAL_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_MOST_RECENT_CLOSING_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_MOST_RECENT_CLOSING_YIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_CLOSING_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDINFLATIONASSUMPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDINFLATIONASSUMPTION);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_TRUEYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_TRUEYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_CLOSINGYIELDMOSTRECENTQUARTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_CLOSINGYIELDMOSTRECENTQUARTER);
  return _val;
}


SWIGINTERN VALUE
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
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
YieldType_INVFLOATERBONDYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_INVFLOATERBONDYIELD);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_YIELDTONEXTPUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTONEXTPUT);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDTONEXTCALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDTONEXTCALL);
  return _val;
}


SWIGINTERN VALUE
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
YieldType_BOOKYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_BOOKYIELD);
  return _val;
}


SWIGINTERN VALUE
YieldType_YIELDVALUEOF132_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::YieldType_YIELDVALUEOF132);
  return _val;
}


SWIGINTERN VALUE
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
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
PegScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
PegScope_NATIONALEXCLUDINGLOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONALEXCLUDINGLOCAL));
  return _val;
}


SWIGINTERN VALUE
PegScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
PegScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
PegScope_LOCALEXCHANGEECNATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegScope_LOCALEXCHANGEECNATS));
  return _val;
}


SWIGINTERN VALUE
SettlDeliveryType_TRI_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_TRI_PARTY));
  return _val;
}


SWIGINTERN VALUE
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
SettlDeliveryType_FREE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE));
  return _val;
}


SWIGINTERN VALUE
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
SettlDeliveryType_FREE_DELIVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE_DELIVER));
  return _val;
}


SWIGINTERN VALUE
SettlDeliveryType_VERSUS_PAYMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_VERSUS_PAYMENT));
  return _val;
}


SWIGINTERN VALUE
DiscretionLimitType_STRICT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_STRICT));
  return _val;
}


SWIGINTERN VALUE
DiscretionLimitType_ORWORSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_ORWORSE));
  return _val;
}


SWIGINTERN VALUE
DiscretionLimitType_OR_BETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_BETTER));
  return _val;
}


SWIGINTERN VALUE
DiscretionLimitType_OR_WORSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_WORSE));
  return _val;
}


SWIGINTERN VALUE
DiscretionLimitType_ORBETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_ORBETTER));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_VALID_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_VALID_REQUEST));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA));
  return _val;
}


SWIGINTERN VALUE
ExerciseMethod_AUTOMATIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_AUTOMATIC));
  return _val;
}


SWIGINTERN VALUE
ExerciseMethod_MANUAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_MANUAL));
  return _val;
}


SWIGINTERN VALUE
WorkingIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
WorkingIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY));
  return _val;
}


SWIGINTERN VALUE
SideMultiLegReportingType_SINGLE_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_SINGLE_SECURITY));
  return _val;
}


SWIGINTERN VALUE
SideMultiLegReportingType_MULTILEG_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTILEG_SECURITY));
  return _val;
}


SWIGINTERN VALUE
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
SideMultiLegReportingType_MULTILEGSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTILEGSECURITY));
  return _val;
}


SWIGINTERN VALUE
SideMultiLegReportingType_SINGLESECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_SINGLESECURITY));
  return _val;
}


SWIGINTERN VALUE
ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
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
ConfirmRejReason_MISMATCHEDACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISMATCHEDACCOUNT));
  return _val;
}


SWIGINTERN VALUE
ConfirmRejReason_MISMATCHED_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISMATCHED_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
ConfirmRejReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
BidRequestTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
BidRequestTransType_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NO));
  return _val;
}


SWIGINTERN VALUE
BidRequestTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
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
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
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
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
MassActionRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
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
CollApplType_GENERAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollApplType_GENERAL));
  return _val;
}


SWIGINTERN VALUE
CollApplType_SPECIFIC_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollApplType_SPECIFIC_DEPOSIT));
  return _val;
}


SWIGINTERN VALUE
ConfirmType_CONFIRMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION));
  return _val;
}


SWIGINTERN VALUE
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
ConfirmType_CONFIRMATIONREQUESTREJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATIONREQUESTREJECTED));
  return _val;
}


SWIGINTERN VALUE
ConfirmType_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmType_STATUS));
  return _val;
}


SWIGINTERN VALUE
MDQuoteType_INDICATIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE));
  return _val;
}


SWIGINTERN VALUE
MDQuoteType_RESTRICTED_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_RESTRICTED_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
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
MDQuoteType_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
MDQuoteType_COUNTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_COUNTER));
  return _val;
}


SWIGINTERN VALUE
QtyType_CONTRACTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QtyType_CONTRACTS));
  return _val;
}


SWIGINTERN VALUE
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
QtyType_UNITS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_END_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_END_TRADE));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_HITLIFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_HITLIFT));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_HIT_LIFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_HIT_LIFT));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_COVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COVER));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_DONE_AWAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_DONE_AWAY));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_DONEAWAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_DONEAWAY));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_TIMED_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TIMED_OUT));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_PASS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_PASS));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
QuoteRespType_COUNTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COUNTER));
  return _val;
}


SWIGINTERN VALUE
IOINaturalFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_NO));
  return _val;
}


SWIGINTERN VALUE
IOINaturalFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_YES));
  return _val;
}


SWIGINTERN VALUE
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
SettlObligSource_INVESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INVESTOR));
  return _val;
}


SWIGINTERN VALUE
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
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
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
TrdSubType_K_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_K));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_LC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LC));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_WN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WN));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_CONVERTED_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CONVERTED_SWAP));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_B_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_B));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_M_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_M));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_RT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RT));
  return _val;
}


SWIGINTERN VALUE
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
TrdSubType_CMTA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CMTA));
  return _val;
}


SWIGINTERN VALUE
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
TrdSubType_DIFFERENTIAL_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_DIFFERENTIAL_SPREAD));
  return _val;
}


SWIGINTERN VALUE
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
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
TrdSubType_N_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_N));
  return _val;
}


SWIGINTERN VALUE
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
TrdSubType_NR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NR));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_SW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_SW));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_OTC_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OTC_QUOTE));
  return _val;
}


SWIGINTERN VALUE
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
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
TrdSubType_P_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_P));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_CROSSED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CROSSED_TRADE));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_PA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PA));
  return _val;
}


SWIGINTERN VALUE
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
TrdSubType_R_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_R));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_RO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RO));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_WT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
TrdSubType_AI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_AI));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_PC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PC));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_PN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PN));
  return _val;
}


SWIGINTERN VALUE
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
TrdSubType_NM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NM));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_T_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_T));
  return _val;
}


SWIGINTERN VALUE
TrdSubType_ACATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ACATS));
  return _val;
}


SWIGINTERN VALUE
ExecTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
ExecTransType_CORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CORRECT));
  return _val;
}


SWIGINTERN VALUE
ExecTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
ExecTransType_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecTransType_STATUS));
  return _val;
}


SWIGINTERN VALUE
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
DayBookingInst_ACCUMULATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_ACCUMULATE));
  return _val;
}


SWIGINTERN VALUE
DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST));
  return _val;
}


SWIGINTERN VALUE
DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
MDOriginType_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDOriginType_CROSS));
  return _val;
}


SWIGINTERN VALUE
MDOriginType_OFF_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDOriginType_OFF_BOOK));
  return _val;
}


SWIGINTERN VALUE
MDOriginType_BOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDOriginType_BOOK));
  return _val;
}


SWIGINTERN VALUE
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
CollInquiryStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryStatus_ACCEPTEDWITHWARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTEDWITHWARNINGS));
  return _val;
}


SWIGINTERN VALUE
CollInquiryStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
CollInquiryStatus_COMPLETEDWITHWARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETEDWITHWARNINGS));
  return _val;
}


SWIGINTERN VALUE
CollInquiryStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
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
CPProgram_3A3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_3A3));
  return _val;
}


SWIGINTERN VALUE
CPProgram_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_OTHER));
  return _val;
}


SWIGINTERN VALUE
CPProgram_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_3));
  return _val;
}


SWIGINTERN VALUE
CPProgram_42_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_42));
  return _val;
}


SWIGINTERN VALUE
CPProgram_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CPProgram_4));
  return _val;
}


SWIGINTERN VALUE
PosReqType_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
PosReqType_BACKOUT_MESSAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_BACKOUT_MESSAGE));
  return _val;
}


SWIGINTERN VALUE
PosReqType_DELTA_POSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_DELTA_POSITIONS));
  return _val;
}


SWIGINTERN VALUE
PosReqType_SETTLEMENT_ACTIVITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_SETTLEMENT_ACTIVITY));
  return _val;
}


SWIGINTERN VALUE
PosReqType_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_TRADES));
  return _val;
}


SWIGINTERN VALUE
PosReqType_EXERCISES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_EXERCISES));
  return _val;
}


SWIGINTERN VALUE
PosReqType_ASSIGNMENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqType_ASSIGNMENTS));
  return _val;
}


SWIGINTERN VALUE
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
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
MassStatusReqType_STATUSSECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSSECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
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
MassStatusReqType_STATUSTRDSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSTRDSESSION));
  return _val;
}


SWIGINTERN VALUE
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
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
MassStatusReqType_STATUSCFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSCFICODE));
  return _val;
}


SWIGINTERN VALUE
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
MassStatusReqType_STATUSUNDERLYINGSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSUNDERLYINGSECURITY));
  return _val;
}


SWIGINTERN VALUE
MassStatusReqType_STATUSPARTYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSPARTYID));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
MassStatusReqType_STATUSSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSSECURITY));
  return _val;
}


SWIGINTERN VALUE
MassStatusReqType_STATUSPRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSPRODUCT));
  return _val;
}


SWIGINTERN VALUE
MassStatusReqType_STATUSALLORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUSALLORDERS));
  return _val;
}


SWIGINTERN VALUE
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
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
SubscriptionRequestType_SNAPSHOTUPDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOTUPDATE));
  return _val;
}


SWIGINTERN VALUE
SubscriptionRequestType_SNAPSHOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT));
  return _val;
}


SWIGINTERN VALUE
SubscriptionRequestType_UNSUBSCRIBE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_UNSUBSCRIBE));
  return _val;
}


SWIGINTERN VALUE
NewsCategory_MARKETPLACE_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_MARKETPLACE_NEWS));
  return _val;
}


SWIGINTERN VALUE
NewsCategory_TECHNICAL_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_TECHNICAL_NEWS));
  return _val;
}


SWIGINTERN VALUE
NewsCategory_COMPANY_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_COMPANY_NEWS));
  return _val;
}


SWIGINTERN VALUE
NewsCategory_OTHER_NEWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsCategory_OTHER_NEWS));
  return _val;
}


SWIGINTERN VALUE
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
IOIQty_MEDIUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_MEDIUM);
  return _val;
}


SWIGINTERN VALUE
IOIQty_1000000000_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_1000000000);
  return _val;
}


SWIGINTERN VALUE
IOIQty_LARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_LARGE);
  return _val;
}


SWIGINTERN VALUE
IOIQty_SMALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_SMALL);
  return _val;
}


SWIGINTERN VALUE
IOIQty_UNDISCLOSED_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::IOIQty_UNDISCLOSED_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
LastLiquidityInd_ADDEDLIQUIDITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_ADDEDLIQUIDITY));
  return _val;
}


SWIGINTERN VALUE
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
LastLiquidityInd_LIQUIDITYROUTEDOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_LIQUIDITYROUTEDOUT));
  return _val;
}


SWIGINTERN VALUE
LastLiquidityInd_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_AUCTION));
  return _val;
}


SWIGINTERN VALUE
LastLiquidityInd_REMOVEDLIQUIDITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVEDLIQUIDITY));
  return _val;
}


SWIGINTERN VALUE
LastLiquidityInd_ADDED_LIQUIDITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_ADDED_LIQUIDITY));
  return _val;
}


SWIGINTERN VALUE
LastLiquidityInd_REMOVED_LIQUIDITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVED_LIQUIDITY));
  return _val;
}


SWIGINTERN VALUE
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
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
StrikePriceDeterminationMethod_FIXED_STRIKE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_FIXED_STRIKE));
  return _val;
}


SWIGINTERN VALUE
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
TargetStrategy_MININIZEMARKETIMPACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_MININIZEMARKETIMPACT));
  return _val;
}


SWIGINTERN VALUE
TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES));
  return _val;
}


SWIGINTERN VALUE
TargetStrategy_PARTICIPATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_PARTICIPATE));
  return _val;
}


SWIGINTERN VALUE
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
TargetStrategy_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_VWAP));
  return _val;
}


SWIGINTERN VALUE
DueToRelated_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DueToRelated_NO));
  return _val;
}


SWIGINTERN VALUE
DueToRelated_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DueToRelated_YES));
  return _val;
}


SWIGINTERN VALUE
UnderlyingCashType_DIFF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnderlyingCashType_DIFF);
  return _val;
}


SWIGINTERN VALUE
UnderlyingCashType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnderlyingCashType_FIXED);
  return _val;
}


SWIGINTERN VALUE
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
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
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
CustOrderCapacity_ALL_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_ALL_OTHER));
  return _val;
}


SWIGINTERN VALUE
OwnershipType_JOINT_TRUSTEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_TRUSTEES));
  return _val;
}


SWIGINTERN VALUE
OwnershipType_JOINT_INVESTORS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_INVESTORS));
  return _val;
}


SWIGINTERN VALUE
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
UnitOfMeasure_US_DOLLARS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_DOLLARS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_TROY_OUNCES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_TROY_OUNCES);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_TONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_TONS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_BILLION_CUBIC_FEET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_BILLION_CUBIC_FEET);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_ONE_MILLION_BTU_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_ONE_MILLION_BTU);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_MEGAWATT_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_HOURS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_MILLION_BARRELS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILLION_BARRELS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_GALLONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_GALLONS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_BARRELS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_BARRELS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_POUNDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_POUNDS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_METRIC_TONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_METRIC_TONS);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_ALLOWANCES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_ALLOWANCES);
  return _val;
}


SWIGINTERN VALUE
UnitOfMeasure_BUSHELS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::UnitOfMeasure_BUSHELS);
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_INVALID_DEFINITION_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_INVALID_DEFINITION_REQUEST));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_PENDING_APPROVAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_PENDING_APPROVAL));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_APPROVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_APPROVED));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_UNAUTHORIZEDREQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_UNAUTHORIZEDREQUEST));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_PENDINGAPPROVAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_PENDINGAPPROVAL));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_UNAUTHORIZED_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_UNAUTHORIZED_REQUEST));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_INVALIDDEFINITIONREQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_INVALIDDEFINITIONREQUEST));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_APPROVEDACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_APPROVEDACCEPTED));
  return _val;
}


SWIGINTERN VALUE
SecDefStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecDefStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
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
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
SettlmntTyp_FUTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_FUTURE));
  return _val;
}


SWIGINTERN VALUE
SettlmntTyp_SELLERS_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_SELLERS_OPTION));
  return _val;
}


SWIGINTERN VALUE
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
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
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
SettlmntTyp_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_REGULAR));
  return _val;
}


SWIGINTERN VALUE
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
SettlmntTyp_WHEN_ISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_WHEN_ISSUED));
  return _val;
}


SWIGINTERN VALUE
SettlmntTyp_NEXT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_NEXT_DAY));
  return _val;
}


SWIGINTERN VALUE
SettlmntTyp_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_CASH));
  return _val;
}


SWIGINTERN VALUE
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
TradePublishIndicator_DEFERRED_PUBLICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DEFERRED_PUBLICATION));
  return _val;
}


SWIGINTERN VALUE
TradePublishIndicator_PUBLISH_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_PUBLISH_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
StandInstDbType_SID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_SID));
  return _val;
}


SWIGINTERN VALUE
StandInstDbType_DTC_SID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_DTC_SID));
  return _val;
}


SWIGINTERN VALUE
StandInstDbType_CUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_CUSTODIAN));
  return _val;
}


SWIGINTERN VALUE
StandInstDbType_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_ALERT));
  return _val;
}


SWIGINTERN VALUE
StandInstDbType_ACCOUNTNET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_ACCOUNTNET));
  return _val;
}


SWIGINTERN VALUE
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
StandInstDbType_THOMSON_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_THOMSON_ALERT));
  return _val;
}


SWIGINTERN VALUE
StandInstDbType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
QuoteEntryStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryStatus_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
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
QuoteEntryStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
QuoteEntryStatus_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACTIVE));
  return _val;
}


SWIGINTERN VALUE
TriggerPriceType_BEST_MID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_MID));
  return _val;
}


SWIGINTERN VALUE
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
TriggerPriceType_BEST_BID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID));
  return _val;
}


SWIGINTERN VALUE
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
TriggerPriceType_BEST_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER));
  return _val;
}


SWIGINTERN VALUE
TriggerPriceType_LAST_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_LAST_TRADE));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_EXTERNAL_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_EXTERNAL_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_TRANSACTION_FROM_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_TRANSACTION_FROM_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_DIFFERENTIAL_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_DIFFERENTIAL_SPREAD));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_CMTA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_CMTA));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_INTERNAL_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_INTERNAL_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION));
  return _val;
}


SWIGINTERN VALUE
SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE));
  return _val;
}


SWIGINTERN VALUE
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
SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND));
  return _val;
}


SWIGINTERN VALUE
SettlInstReqRejCode_UNKNOWNACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNKNOWNACCOUNT));
  return _val;
}


SWIGINTERN VALUE
SettlInstReqRejCode_UNABLETOPROCESSREQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNABLETOPROCESSREQUEST));
  return _val;
}


SWIGINTERN VALUE
SettlInstReqRejCode_UNKNOWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNKNOWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
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
SettlInstReqRejCode_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_OTHER));
  return _val;
}


SWIGINTERN VALUE
Urgency_FLASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Urgency_FLASH));
  return _val;
}


SWIGINTERN VALUE
Urgency_NORMAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Urgency_NORMAL));
  return _val;
}


SWIGINTERN VALUE
Urgency_BACKGROUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Urgency_BACKGROUND));
  return _val;
}


SWIGINTERN VALUE
CollAsgnTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
CollAsgnTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
CollAsgnTransType_REVERSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REVERSE));
  return _val;
}


SWIGINTERN VALUE
CollAsgnTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
CollAsgnTransType_RELEASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_RELEASE));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_FED_WIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FED_WIRE));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_ACHCREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACHCREDIT));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_TELEGRAPHICTRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_TELEGRAPHICTRANSFER));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_DIRECTDEBITBECS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECTDEBITBECS));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_EUROCLEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_EUROCLEAR));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_ACH_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_CREDIT));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_TELEGRAPHIC_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_TELEGRAPHIC_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_FEDWIRE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FEDWIRE));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_CREDITCARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREDITCARD));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_DIRECT_DEBIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_DEBIT));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_CREDIT_CARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREDIT_CARD));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_CHEQUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CHEQUE));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_DIRECT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_CREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREST));
  return _val;
}


SWIGINTERN VALUE
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
PaymentMethod_DEBITCARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DEBITCARD));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_CLEARSTREAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CLEARSTREAM));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_BPAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_BPAY));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_NSCC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_NSCC));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_DEBIT_CARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DEBIT_CARD));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_ACHDEBIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACHDEBIT));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_DIRECTCREDITBECS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECTCREDITBECS));
  return _val;
}


SWIGINTERN VALUE
PaymentMethod_ACH_DEBIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_DEBIT));
  return _val;
}


SWIGINTERN VALUE
TriggerPriceTypeScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
TriggerPriceTypeScope_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NONE));
  return _val;
}


SWIGINTERN VALUE
TriggerPriceTypeScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
TriggerPriceTypeScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
PegLimitType_STRICT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_STRICT));
  return _val;
}


SWIGINTERN VALUE
PegLimitType_ORWORSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_ORWORSE));
  return _val;
}


SWIGINTERN VALUE
PegLimitType_OR_BETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_BETTER));
  return _val;
}


SWIGINTERN VALUE
PegLimitType_OR_WORSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_WORSE));
  return _val;
}


SWIGINTERN VALUE
PegLimitType_ORBETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegLimitType_ORBETTER));
  return _val;
}


SWIGINTERN VALUE
Side_BORROW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BORROW));
  return _val;
}


SWIGINTERN VALUE
Side_SELLPLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELLPLUS));
  return _val;
}


SWIGINTERN VALUE
Side_BUY_MINUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BUY_MINUS));
  return _val;
}


SWIGINTERN VALUE
Side_BUYMIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BUYMIN));
  return _val;
}


SWIGINTERN VALUE
Side_ASDEFINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_ASDEFINED));
  return _val;
}


SWIGINTERN VALUE
Side_SUBSCRIBE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SUBSCRIBE));
  return _val;
}


SWIGINTERN VALUE
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
Side_UNDISCLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_UNDISCLOSED));
  return _val;
}


SWIGINTERN VALUE
Side_SELLSHT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELLSHT));
  return _val;
}


SWIGINTERN VALUE
Side_SELLSHTEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELLSHTEX));
  return _val;
}


SWIGINTERN VALUE
Side_CROSSSHORTEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSSSHORTEX));
  return _val;
}


SWIGINTERN VALUE
Side_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSS));
  return _val;
}


SWIGINTERN VALUE
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
Side_UNDISC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_UNDISC));
  return _val;
}


SWIGINTERN VALUE
Side_CROSSSHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSSSHORT));
  return _val;
}


SWIGINTERN VALUE
Side_BORROWFINANCING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BORROWFINANCING));
  return _val;
}


SWIGINTERN VALUE
Side_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_BUY));
  return _val;
}


SWIGINTERN VALUE
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
Side_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELL));
  return _val;
}


SWIGINTERN VALUE
Side_LEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_LEND));
  return _val;
}


SWIGINTERN VALUE
Side_SELL_SHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT));
  return _val;
}


SWIGINTERN VALUE
Side_OPPOSITE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_OPPOSITE));
  return _val;
}


SWIGINTERN VALUE
Side_CROSS_SHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT));
  return _val;
}


SWIGINTERN VALUE
Side_SELL_PLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_SELL_PLUS));
  return _val;
}


SWIGINTERN VALUE
Side_REDEEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_REDEEM));
  return _val;
}


SWIGINTERN VALUE
Side_LENDFINANCING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_LENDFINANCING));
  return _val;
}


SWIGINTERN VALUE
Side_AS_DEFINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Side_AS_DEFINED));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_COMMISSIONAMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSIONAMT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_FUNDBASEDRENEWALCOMM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUNDBASEDRENEWALCOMM));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_INITIALCHARGEPCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIALCHARGEPCT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_EXITCHARGEAMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXITCHARGEAMT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_EXIT_CHARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE));
  return _val;
}


SWIGINTERN VALUE
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
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
ContAmtType_DISCOUNT_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_COMMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION));
  return _val;
}


SWIGINTERN VALUE
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
ContAmtType_DILUTIONLEVYAMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTIONLEVYAMT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_DILUTION_LEVY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_COMMISSION_AMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_AMOUNT));
  return _val;
}


SWIGINTERN VALUE
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
ContAmtType_EXITCHARGEPCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXITCHARGEPCT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_COMMISSIONPCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSIONPCT));
  return _val;
}


SWIGINTERN VALUE
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
ContAmtType_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_FUNDBASEDRENEWALCOMMAMTORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUNDBASEDRENEWALCOMMAMTORD));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_DISCOUNTPCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNTPCT));
  return _val;
}


SWIGINTERN VALUE
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
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
ContAmtType_INITIAL_CHARGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE));
  return _val;
}


SWIGINTERN VALUE
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
ContAmtType_DISCOUNT_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_PERCENT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_INITIALCHARGEAMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIALCHARGEAMT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_DILUTIONLEVYPCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTIONLEVYPCT));
  return _val;
}


SWIGINTERN VALUE
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
ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_NETSETTLEMENTAMOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_NETSETTLEMENTAMOUNT));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_PROJECTEDFUNDVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_PROJECTEDFUNDVALUE));
  return _val;
}


SWIGINTERN VALUE
ContAmtType_DISCOUNTAMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNTAMT));
  return _val;
}


SWIGINTERN VALUE
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
ContAmtType_COMMISSION_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_PERCENT));
  return _val;
}


SWIGINTERN VALUE
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
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
OrderCategory_IMPLIED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_IMPLIED_ORDER));
  return _val;
}


SWIGINTERN VALUE
OrderCategory_STREAMING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_STREAMING_PRICE));
  return _val;
}


SWIGINTERN VALUE
OrderCategory_QUOTE_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE_REQUEST));
  return _val;
}


SWIGINTERN VALUE
OrderCategory_CROSS_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_CROSS_ORDER));
  return _val;
}


SWIGINTERN VALUE
OrderCategory_MULTILEG_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_MULTILEG_ORDER));
  return _val;
}


SWIGINTERN VALUE
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
OrderCategory_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE));
  return _val;
}


SWIGINTERN VALUE
OrderCategory_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_ORDER));
  return _val;
}


SWIGINTERN VALUE
OrderCategory_LINKED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrderCategory_LINKED_ORDER));
  return _val;
}


SWIGINTERN VALUE
AdvTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_REPLACE);
  return _val;
}


SWIGINTERN VALUE
AdvTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_NEW);
  return _val;
}


SWIGINTERN VALUE
AdvTransType_ADVCANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_ADVCANCEL);
  return _val;
}


SWIGINTERN VALUE
AdvTransType_ADVREPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_ADVREPLACE);
  return _val;
}


SWIGINTERN VALUE
AdvTransType_ADVNEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_ADVNEW);
  return _val;
}


SWIGINTERN VALUE
AdvTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::AdvTransType_CANCEL);
  return _val;
}


SWIGINTERN VALUE
PublishTrdIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
PublishTrdIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
SecurityResponseType_ACCPTSECPROPREV_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCPTSECPROPREV));
  return _val;
}


SWIGINTERN VALUE
SecurityResponseType_SECLISTTYPESRET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_SECLISTTYPESRET));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
SecurityResponseType_ACCPTSECPROP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCPTSECPROP));
  return _val;
}


SWIGINTERN VALUE
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
SecurityResponseType_SECLISTRET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_SECLISTRET));
  return _val;
}


SWIGINTERN VALUE
SecurityResponseType_REJSECPROP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_REJSECPROP));
  return _val;
}


SWIGINTERN VALUE
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
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
SecurityResponseType_NOMATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_NOMATCH));
  return _val;
}


SWIGINTERN VALUE
SessionStatus_PASSWORD_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_PASSWORD_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
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
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
SessionStatus_SESSION_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_ACTIVE));
  return _val;
}


SWIGINTERN VALUE
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
SessionStatus_ACCOUNT_LOCKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionStatus_ACCOUNT_LOCKED));
  return _val;
}


SWIGINTERN VALUE
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
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
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
AllocAccountType_JBO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_JBO));
  return _val;
}


SWIGINTERN VALUE
AllocAccountType_HOUSE_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSE_TRADER));
  return _val;
}


SWIGINTERN VALUE
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
AllocAccountType_FLOOR_TRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_FLOOR_TRADER));
  return _val;
}


SWIGINTERN VALUE
AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED));
  return _val;
}


SWIGINTERN VALUE
AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS));
  return _val;
}


SWIGINTERN VALUE
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
AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED));
  return _val;
}


SWIGINTERN VALUE
AllocAccountType_HOUSETRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSETRADER));
  return _val;
}


SWIGINTERN VALUE
AllocAccountType_FLOORTRADER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_FLOORTRADER));
  return _val;
}


SWIGINTERN VALUE
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
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
AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS));
  return _val;
}


SWIGINTERN VALUE
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
AllocTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
AllocTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
AllocTransType_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
AllocTransType_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
AllocTransType_CALCULATEDWITHOUTPRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATEDWITHOUTPRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
AllocTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
AllocTransType_REVERSAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REVERSAL));
  return _val;
}


SWIGINTERN VALUE
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
ExpirationQtyType_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
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
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
ExpirationQtyType_CONTRARY_INTENTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_CONTRARY_INTENTION));
  return _val;
}


SWIGINTERN VALUE
ExpirationQtyType_AUTO_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_AUTO_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
AllocHandlInst_FORWARDMATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARDMATCH));
  return _val;
}


SWIGINTERN VALUE
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
AllocHandlInst_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD));
  return _val;
}


SWIGINTERN VALUE
AllocHandlInst_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_MATCH));
  return _val;
}


SWIGINTERN VALUE
TradeRequestStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
TradeRequestStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
TradeRequestStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
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
PreallocMethod_PRO_RATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_PRO_RATA));
  return _val;
}


SWIGINTERN VALUE
PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST));
  return _val;
}


SWIGINTERN VALUE
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
PreallocMethod_PRORATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_PRORATA));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_ROTHIRANONPROTOTYPEUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHIRANONPROTOTYPEUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_PROFITSHARINGPLANUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PROFITSHARINGPLANUS));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_401_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYER_11_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_11));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_457US_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_457US));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYER_12_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_12));
  return _val;
}


SWIGINTERN VALUE
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
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
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
TaxAdvantageType_EMPLOYEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_SELFDIRECTEDIRAUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_SELFDIRECTEDIRAUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_403_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_403));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_NONFUNDPROTOTYPEIRAUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONFUNDPROTOTYPEIRAUS));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_MAXIISAUK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MAXIISAUK));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_NONFUNDQUALIFIEDPLANUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONFUNDQUALIFIEDPLANUS));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_PRIORYEARPAYMENTUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PRIORYEARPAYMENTUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_TESSAUK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_TESSAUK));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_CURRENTYEARPAYMENTUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_CURRENTYEARPAYMENTUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_KEOGHUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_KEOGHUS));
  return _val;
}


SWIGINTERN VALUE
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
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
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
TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_EMPLOYEE_10_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_10));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYEE_9_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_9));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_MAXI_ISA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MAXI_ISA));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_MINIINSURANCEISAUK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINIINSURANCEISAUK));
  return _val;
}


SWIGINTERN VALUE
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
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
TaxAdvantageType_401K_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401K));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_403BUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_403BUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_MINICASHISAUK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINICASHISAUK));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_MINISTOCKSANDSHARESISAUK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINISTOCKSANDSHARESISAUK));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_OTHER));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYERCURRENTYEARUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYERCURRENTYEARUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_ASSET_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ASSET_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_KEOGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_KEOGH));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_401KUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401KUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_TESSA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_TESSA));
  return _val;
}


SWIGINTERN VALUE
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
TaxAdvantageType_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONE));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_457_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_457));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYEEPRIORYEARUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEEPRIORYEARUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYERPRIORYEARUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYERPRIORYEARUS));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER));
  return _val;
}


SWIGINTERN VALUE
TaxAdvantageType_EMPLOYEECURRENTYEARUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEECURRENTYEARUS));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
TaxAdvantageType_ASSETTRANSFERUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ASSETTRANSFERUS));
  return _val;
}


SWIGINTERN VALUE
MessageEncoding_EUC_JP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_EUC_JP);
  return _val;
}


SWIGINTERN VALUE
MessageEncoding_SHIFT_JIS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_SHIFT_JIS);
  return _val;
}


SWIGINTERN VALUE
MessageEncoding_UTF_8_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_UTF_8);
  return _val;
}


SWIGINTERN VALUE
MessageEncoding_ISO_2022_JP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MessageEncoding_ISO_2022_JP);
  return _val;
}


SWIGINTERN VALUE
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
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
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
TimeInForce_ATTHEOPENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_ATTHEOPENING));
  return _val;
}


SWIGINTERN VALUE
TimeInForce_FILLORKILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_FILLORKILL));
  return _val;
}


SWIGINTERN VALUE
TimeInForce_GOODTILLDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOODTILLDATE));
  return _val;
}


SWIGINTERN VALUE
TimeInForce_GOODTILLCANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOODTILLCANCEL));
  return _val;
}


SWIGINTERN VALUE
TimeInForce_ATTHECLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_ATTHECLOSE));
  return _val;
}


SWIGINTERN VALUE
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
TimeInForce_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_DAY));
  return _val;
}


SWIGINTERN VALUE
TimeInForce_AT_CROSSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_CROSSING));
  return _val;
}


SWIGINTERN VALUE
TimeInForce_IMMEDIATEORCANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_IMMEDIATEORCANCEL));
  return _val;
}


SWIGINTERN VALUE
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
TimeInForce_GOODTILLCROSSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOODTILLCROSSING));
  return _val;
}


SWIGINTERN VALUE
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
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
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
IOIQualifier_AON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AON));
  return _val;
}


SWIGINTERN VALUE
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
IOIQualifier_INDIDCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDIDCATION));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_MOC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MOC));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_READYTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_READYTRADE));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_ATMID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATMID));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_INDWRKAWAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDWRKAWAY));
  return _val;
}


SWIGINTERN VALUE
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
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
IOIQualifier_CROSSING_OPPORTUNITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CROSSING_OPPORTUNITY));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_CURRENT_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CURRENT_QUOTE));
  return _val;
}


SWIGINTERN VALUE
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
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
IOIQualifier_THROUGHDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_THROUGHDAY));
  return _val;
}


SWIGINTERN VALUE
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
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
IOIQualifier_TAKEPOSITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_TAKEPOSITION));
  return _val;
}


SWIGINTERN VALUE
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
IOIQualifier_INTOUCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INTOUCH));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_MOREBEHIND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MOREBEHIND));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_ATMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATMARKET));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_CROSSOPP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CROSSOPP));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_PREOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PREOPEN));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_ATCLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATCLOSE));
  return _val;
}


SWIGINTERN VALUE
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
IOIQualifier_VERSUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VERSUS));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_LIMIT));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_PORTFOLIO_SHOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTFOLIO_SHOWN));
  return _val;
}


SWIGINTERN VALUE
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
IOIQualifier_PRE_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PRE_OPEN));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_INDICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDICATION));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_MORE_BEHIND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MORE_BEHIND));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_ATOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ATOPEN));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VWAP));
  return _val;
}


SWIGINTERN VALUE
IOIQualifier_PORTSHOW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTSHOW));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
MiscFeeType_CONVERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_CONVERSION);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_CONSUMPTION_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_CONSUMPTION_TAX);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_LOCAL_COMMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_LOCAL_COMMISSION);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_TAX);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_LOCALCOMM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_LOCALCOMM);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_MARKUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_MARKUP);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_SECURITY_LENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_SECURITY_LENDING);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_PER_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_PER_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_REGULATORY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_REGULATORY);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_EXCHFEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_EXCHFEE);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_CONSUMPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_CONSUMPTION);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_STAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_STAMP);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_TRANSFER_FEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_TRANSFER_FEE);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_AGENT);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_OTHER);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_REG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_REG);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_EXCHANGE_FEES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_EXCHANGE_FEES);
  return _val;
}


SWIGINTERN VALUE
MiscFeeType_LEVY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MiscFeeType_LEVY);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_CLEARING_HOUSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CLEARING_HOUSE);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_EXCHANGE_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_EXCHANGE_SYMBOL);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_SICOVAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_SICOVAM);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISDA_FPML_PRODUCT_URL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_URL);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_RIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_RIC);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_CLEARINGHOUSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CLEARINGHOUSE);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_FPML_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_FPML);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_RIC_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_RIC_CODE);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISOCURR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISOCURR);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISO_CURRENCY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_CURRENCY_CODE);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_COMMON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_COMMON);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_VALOREN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_VALOREN);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_BELGIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_BELGIAN);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_CTA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CTA);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISIN_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISIN_NUMBER);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISIN);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISOCOUNTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISOCOUNTRY);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_SEDOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_SEDOL);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_ISO_COUNTRY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_COUNTRY_CODE);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_LETTER_OF_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_LETTER_OF_CREDIT);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_BLOOMBERG_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_BLOOMBERG_SYMBOL);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_BLMBRG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_BLMBRG);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_WERTPAPIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_WERTPAPIER);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_EXCHSYMB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_EXCHSYMB);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_DUTCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_DUTCH);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_QUIK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_QUIK);
  return _val;
}


SWIGINTERN VALUE
SecurityIDSource_CUSIP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityIDSource_CUSIP);
  return _val;
}


SWIGINTERN VALUE
NewsRefType_OTHER_LANGUAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsRefType_OTHER_LANGUAGE));
  return _val;
}


SWIGINTERN VALUE
NewsRefType_COMPLIMENTARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsRefType_COMPLIMENTARY));
  return _val;
}


SWIGINTERN VALUE
NewsRefType_REPLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NewsRefType_REPLACEMENT));
  return _val;
}


SWIGINTERN VALUE
TriggerOrderType_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_LIMIT));
  return _val;
}


SWIGINTERN VALUE
TriggerOrderType_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_MARKET));
  return _val;
}


SWIGINTERN VALUE
CrossType_CROSS_AON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_AON));
  return _val;
}


SWIGINTERN VALUE
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
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
CrossType_CROSSAON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSAON));
  return _val;
}


SWIGINTERN VALUE
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
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
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
CrossType_CROSSSAMEPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSSAMEPRICE));
  return _val;
}


SWIGINTERN VALUE
CrossType_CROSS_IOC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_IOC));
  return _val;
}


SWIGINTERN VALUE
CrossType_CROSSIOC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSIOC));
  return _val;
}


SWIGINTERN VALUE
CrossType_CROSSONESIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSSONESIDE));
  return _val;
}


SWIGINTERN VALUE
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
OpenCloseSettleFlag_SESSION_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_SESSION_OPEN));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettleFlag_DAILY_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DAILY_OPEN));
  return _val;
}


SWIGINTERN VALUE
OpenCloseSettleFlag_EXPECTED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_EXPECTED_PRICE));
  return _val;
}


SWIGINTERN VALUE
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
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
MDBookType_PRICE_DEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDBookType_PRICE_DEPTH));
  return _val;
}


SWIGINTERN VALUE
MDBookType_ORDER_DEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDBookType_ORDER_DEPTH));
  return _val;
}


SWIGINTERN VALUE
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
BasisPxType_VWAPAFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPAFT));
  return _val;
}


SWIGINTERN VALUE
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
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
BasisPxType_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE));
  return _val;
}


SWIGINTERN VALUE
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
BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_VWAPDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPDAY));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_VWAPMORNXYORI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPMORNXYORI));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_VWAPMORN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPMORN));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_VWAPDAYXYORI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPDAYXYORI));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_OTHERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OTHERS));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OPEN));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_CURRPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CURRPX));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_VWAPAFTXYORI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAPAFTXYORI));
  return _val;
}


SWIGINTERN VALUE
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
BasisPxType_CLSPXMORN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLSPXMORN));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_CURRENT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CURRENT_PRICE));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_SQ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_SQ));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_CLSPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLSPX));
  return _val;
}


SWIGINTERN VALUE
BasisPxType_STRIKE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::BasisPxType_STRIKE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
ComplexEventType_ROLLING_BARRIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_ROLLING_BARRIER));
  return _val;
}


SWIGINTERN VALUE
ComplexEventType_UNDERLYING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_UNDERLYING));
  return _val;
}


SWIGINTERN VALUE
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
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
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
ComplexEventType_TRIGGER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_TRIGGER));
  return _val;
}


SWIGINTERN VALUE
ComplexEventType_RESET_BARRIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_RESET_BARRIER));
  return _val;
}


SWIGINTERN VALUE
ComplexEventType_CAPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_CAPPED));
  return _val;
}


SWIGINTERN VALUE
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
MassActionResponse_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_REJECTED));
  return _val;
}


SWIGINTERN VALUE
MassActionResponse_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
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
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
SecurityRequestType_REQSECIDPROV_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECIDPROV));
  return _val;
}


SWIGINTERN VALUE
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
SecurityRequestType_REQSECID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECID));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestType_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
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
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
SecurityRequestType_REQSECLIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECLIST));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestType_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestType_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestType_ALL_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_ALL_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
SecurityRequestType_REQSECLISTTYPES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQSECLISTTYPES));
  return _val;
}


SWIGINTERN VALUE
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
ListRejectReason_EXCHANGE_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_EXCHANGE_CLOSED));
  return _val;
}


SWIGINTERN VALUE
ListRejectReason_UNKNOWN_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNKNOWN_ORDER));
  return _val;
}


SWIGINTERN VALUE
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
ListRejectReason_DUPLICATE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_DUPLICATE_ORDER));
  return _val;
}


SWIGINTERN VALUE
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
ListRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
ListRejectReason_BROKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_BROKER));
  return _val;
}


SWIGINTERN VALUE
DeskType_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_PROPRIETARY);
  return _val;
}


SWIGINTERN VALUE
DeskType_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_ARBITRAGE);
  return _val;
}


SWIGINTERN VALUE
DeskType_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_TRADING);
  return _val;
}


SWIGINTERN VALUE
DeskType_DERIVATIVES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_DERIVATIVES);
  return _val;
}


SWIGINTERN VALUE
DeskType_SALES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_SALES);
  return _val;
}


SWIGINTERN VALUE
DeskType_INSTITUTIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_INSTITUTIONAL);
  return _val;
}


SWIGINTERN VALUE
DeskType_INTERNATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_INTERNATIONAL);
  return _val;
}


SWIGINTERN VALUE
DeskType_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_AGENCY);
  return _val;
}


SWIGINTERN VALUE
DeskType_PREFERRED_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_PREFERRED_TRADING);
  return _val;
}


SWIGINTERN VALUE
DeskType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_OTHER);
  return _val;
}


SWIGINTERN VALUE
DeskType_PROGRAM_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskType_PROGRAM_TRADING);
  return _val;
}


SWIGINTERN VALUE
SettlType_T4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T4);
  return _val;
}


SWIGINTERN VALUE
SettlType_T5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T5);
  return _val;
}


SWIGINTERN VALUE
SettlType_WHEN_AND_IF_ISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_WHEN_AND_IF_ISSUED);
  return _val;
}


SWIGINTERN VALUE
SettlType_NEXTDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_NEXTDAY);
  return _val;
}


SWIGINTERN VALUE
SettlType_FUTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_FUTURE);
  return _val;
}


SWIGINTERN VALUE
SettlType_T_PLUS_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_2);
  return _val;
}


SWIGINTERN VALUE
SettlType_SELLERS_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_SELLERS_OPTION);
  return _val;
}


SWIGINTERN VALUE
SettlType_BROKEN_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_BROKEN_DATE);
  return _val;
}


SWIGINTERN VALUE
SettlType_T_PLUS_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_3);
  return _val;
}


SWIGINTERN VALUE
SettlType_T_PLUS_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_4);
  return _val;
}


SWIGINTERN VALUE
SettlType_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_REGULAR);
  return _val;
}


SWIGINTERN VALUE
SettlType_NEXT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_NEXT_DAY);
  return _val;
}


SWIGINTERN VALUE
SettlType_T_PLUS_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_5);
  return _val;
}


SWIGINTERN VALUE
SettlType_FX_SPOT_NEXT_SETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_FX_SPOT_NEXT_SETTLEMENT);
  return _val;
}


SWIGINTERN VALUE
SettlType_T1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T1);
  return _val;
}


SWIGINTERN VALUE
SettlType_WHENISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_WHENISSUED);
  return _val;
}


SWIGINTERN VALUE
SettlType_T2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T2);
  return _val;
}


SWIGINTERN VALUE
SettlType_T3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_T3);
  return _val;
}


SWIGINTERN VALUE
SettlType_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlType_CASH);
  return _val;
}


SWIGINTERN VALUE
OpenClose_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenClose_CLOSE));
  return _val;
}


SWIGINTERN VALUE
OpenClose_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OpenClose_OPEN));
  return _val;
}


SWIGINTERN VALUE
ContractMultiplierUnit_SHARES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_SHARES));
  return _val;
}


SWIGINTERN VALUE
ContractMultiplierUnit_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_HOURS));
  return _val;
}


SWIGINTERN VALUE
ContractMultiplierUnit_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_DAYS));
  return _val;
}


SWIGINTERN VALUE
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
TrdType_LATE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
TrdType_CASH_SETTLEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_CASH_SETTLEMENT));
  return _val;
}


SWIGINTERN VALUE
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
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
TrdType_BLOCK_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADES));
  return _val;
}


SWIGINTERN VALUE
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
TrdType_OPTION_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
TrdType_FINANCING_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_FINANCING_TRANSACTION));
  return _val;
}


SWIGINTERN VALUE
TrdType_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
TrdType_REGULAR_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_REGULAR_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
TrdType_SPECIAL_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_PRICE));
  return _val;
}


SWIGINTERN VALUE
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
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
TrdType_BLOCKTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCKTRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
TrdType_ERROR_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_ERROR_TRADE));
  return _val;
}


SWIGINTERN VALUE
TrdType_NAME_CHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_NAME_CHANGE));
  return _val;
}


SWIGINTERN VALUE
TrdType_LATEBUNCHEDTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_LATEBUNCHEDTRADE));
  return _val;
}


SWIGINTERN VALUE
TrdType_EFP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_EFP));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
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
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
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
TrdType_GUARANTEED_DELIVERY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_GUARANTEED_DELIVERY));
  return _val;
}


SWIGINTERN VALUE
TrdType_PROROGATION_SELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_SELL));
  return _val;
}


SWIGINTERN VALUE
TrdType_WEIGHTEDAVERAGEPRICETRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_WEIGHTEDAVERAGEPRICETRADE));
  return _val;
}


SWIGINTERN VALUE
TrdType_PORTFOLIO_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
TrdType_PORTFOLIO_TRANSFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRANSFER));
  return _val;
}


SWIGINTERN VALUE
TrdType_T_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_T_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
TrdType_BUNCHEDTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BUNCHEDTRADE));
  return _val;
}


SWIGINTERN VALUE
TrdType_TTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_TTRADE));
  return _val;
}


SWIGINTERN VALUE
TrdType_OTC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_OTC));
  return _val;
}


SWIGINTERN VALUE
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
TrdType_PRIORREFERENCEPRICETRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIORREFERENCEPRICETRADE));
  return _val;
}


SWIGINTERN VALUE
TrdType_AFTERHOURSTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_AFTERHOURSTRADE));
  return _val;
}


SWIGINTERN VALUE
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
TrdType_REPURCHASE_AGREEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_REPURCHASE_AGREEMENT));
  return _val;
}


SWIGINTERN VALUE
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
TrdType_PROROGATION_BUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_BUY));
  return _val;
}


SWIGINTERN VALUE
TrdType_BUNCHED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_BUNCHED_TRADE));
  return _val;
}


SWIGINTERN VALUE
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
TrdType_LATETRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_LATETRADE));
  return _val;
}


SWIGINTERN VALUE
TrdType_REGULARTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdType_REGULARTRADE));
  return _val;
}


SWIGINTERN VALUE
RestructuringType_MODIFIED_MOD_RESTRUCTURING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_MOD_RESTRUCTURING);
  return _val;
}


SWIGINTERN VALUE
RestructuringType_FULL_RESTRUCTURING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_FULL_RESTRUCTURING);
  return _val;
}


SWIGINTERN VALUE
RestructuringType_NO_RESTRUCTURING_SPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_NO_RESTRUCTURING_SPECIFIED);
  return _val;
}


SWIGINTERN VALUE
RestructuringType_MODIFIED_RESTRUCTURING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_RESTRUCTURING);
  return _val;
}


SWIGINTERN VALUE
ProgRptReqs_SELLSIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_SELLSIDE));
  return _val;
}


SWIGINTERN VALUE
ProgRptReqs_REALTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_REALTIME));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
ProgRptReqs_BUYSIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_BUYSIDE));
  return _val;
}


SWIGINTERN VALUE
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
TradingSessionID_EVENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_EVENING);
  return _val;
}


SWIGINTERN VALUE
TradingSessionID_AFTER_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_AFTER_HOURS);
  return _val;
}


SWIGINTERN VALUE
TradingSessionID_HALFDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_HALFDAY);
  return _val;
}


SWIGINTERN VALUE
TradingSessionID_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_DAY);
  return _val;
}


SWIGINTERN VALUE
TradingSessionID_MORNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_MORNING);
  return _val;
}


SWIGINTERN VALUE
TradingSessionID_AFTERNOON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradingSessionID_AFTERNOON);
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_RECVFOREXEC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECVFOREXEC));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_CXL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CXL));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_REJ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_REJ));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_CANCELING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELING));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_REJECT));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_ALL_DONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALL_DONE));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_INBIDPROC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_INBIDPROC));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_ALLDONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALLDONE));
  return _val;
}


SWIGINTERN VALUE
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
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
ListOrderStatus_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALERT));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_RECEIVEDFOREXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECEIVEDFOREXECUTION));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_INBIDDINGPROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_INBIDDINGPROCESS));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_EXEC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_EXEC));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_CANCELLING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELLING));
  return _val;
}


SWIGINTERN VALUE
ListOrderStatus_EXECUTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_EXECUTING));
  return _val;
}


SWIGINTERN VALUE
RegistStatus_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECT));
  return _val;
}


SWIGINTERN VALUE
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
RegistStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
RegistStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
RegistStatus_REMINDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REMINDER));
  return _val;
}


SWIGINTERN VALUE
RegistStatus_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_HELD));
  return _val;
}


SWIGINTERN VALUE
RegistStatus_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE));
  return _val;
}


SWIGINTERN VALUE
UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE));
  return _val;
}


SWIGINTERN VALUE
UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_AVERAGE_VALUE));
  return _val;
}


SWIGINTERN VALUE
UnderlyingPriceDeterminationMethod_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_REGULAR));
  return _val;
}


SWIGINTERN VALUE
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
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
MassCancelRequestType_CXLORDERSSECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSSECURITYTYPE));
  return _val;
}


SWIGINTERN VALUE
MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY));
  return _val;
}


SWIGINTERN VALUE
MassCancelRequestType_CXLORDERSTRDSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSTRDSESSION));
  return _val;
}


SWIGINTERN VALUE
MassCancelRequestType_CXLALLORDERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLALLORDERS));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
MassCancelRequestType_CXLORDERSSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSSECURITY));
  return _val;
}


SWIGINTERN VALUE
MassCancelRequestType_CXLORDERSPRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSPRODUCT));
  return _val;
}


SWIGINTERN VALUE
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
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
MassCancelRequestType_CXLORDERSCFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CXLORDERSCFICODE));
  return _val;
}


SWIGINTERN VALUE
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
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
DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_UNDELYINGSYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_UNDELYINGSYMBOL));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_UNDERLYING_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_UNDERLYING_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_ALL_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_ALL_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
DerivativeSecurityListRequestType_PRODUCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DerivativeSecurityListRequestType_PRODUCT));
  return _val;
}


SWIGINTERN VALUE
CxlRejResponseTo_ORDCXLREPREQ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDCXLREPREQ));
  return _val;
}


SWIGINTERN VALUE
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
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
CxlRejResponseTo_ORDCXLREQ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDCXLREQ));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
QuoteCancelType_CXLUNDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLUNDER));
  return _val;
}


SWIGINTERN VALUE
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
QuoteCancelType_CXLSYM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLSYM));
  return _val;
}


SWIGINTERN VALUE
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
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
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
QuoteCancelType_CXLSECTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLSECTYPE));
  return _val;
}


SWIGINTERN VALUE
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
QuoteCancelType_CXLALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CXLALL));
  return _val;
}


SWIGINTERN VALUE
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
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
StipulationType_POOLS_PER_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_LOT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MAXIMUM_LOAN_BALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_LOAN_BALANCE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CONSTANTPREPAYMENTYIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANTPREPAYMENTYIELD);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CUSTOM_START_END_DATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CUSTOM_START_END_DATE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CALL_PROTECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CALL_PROTECTION);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MATURITYYEARANDMONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITYYEARANDMONTH);
  return _val;
}


SWIGINTERN VALUE
StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MATURITYRANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITYRANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_COUPON_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_COUPON_RANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PERCENTOFBMAPREPAYMENTCURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PERCENTOFBMAPREPAYMENTCURVE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_SUBSTITUTIONSLEFTREPO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONSLEFTREPO);
  return _val;
}


SWIGINTERN VALUE
StipulationType_LOOKBACKDAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_LOOKBACKDAYS);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CALLPROTECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CALLPROTECTION);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MAXIMUMSUBSTITUTIONSREPO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUMSUBSTITUTIONSREPO);
  return _val;
}


SWIGINTERN VALUE
StipulationType_YEARORYEARMONTHOFISSUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YEARORYEARMONTHOFISSUE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CONSTANTPREPAYMENTRATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANTPREPAYMENTRATE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ISSUE_SIZE_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISSUE_SIZE_RANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WEIGHTEDAVERAGEMATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGEMATURITY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CONSTANT_PREPAYMENT_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_RATE);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_POOLSMINIMUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLSMINIMUM);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_BROKERS_SALES_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BROKERS_SALES_CREDIT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ORDER_QUANTITY_INCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ORDER_QUANTITY_INCREMENT);
  return _val;
}


SWIGINTERN VALUE
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
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
StipulationType_ISSUERS_TICKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISSUERS_TICKER);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ISOCURRENCYCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISOCURRENCYCODE);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_DISCOUNT_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_DISCOUNT_RATE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_VALUATIONDISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_VALUATIONDISCOUNT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_SINGLE_MONTHLY_MORTALITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SINGLE_MONTHLY_MORTALITY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_LOT_VARIANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_LOT_VARIANCE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_FREEFORMTEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_FREEFORMTEXT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WHOLE_POOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WHOLE_POOL);
  return _val;
}


SWIGINTERN VALUE
StipulationType_GEOGRAPHICS_AND_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS_AND_RANGE);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_FREEFORM_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_FREEFORM_TEXT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_RATING_SOURCE_AND_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_RATING_SOURCE_AND_RANGE);
  return _val;
}


SWIGINTERN VALUE
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
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
StipulationType_NUMBER_OF_PIECES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_NUMBER_OF_PIECES);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MINIMUM_INCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_INCREMENT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PRODUCTIONYEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRODUCTIONYEAR);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WEIGHTED_AVERAGE_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_MATURITY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_GEOGRAPHICS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MINIMUMQUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUMQUANTITY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_POOL_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOL_IDENTIFIER);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MATURITY_YEAR_AND_MONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR_AND_MONTH);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PRICINGFREQUENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRICINGFREQUENCY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_EXPLICITLOTIDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_EXPLICITLOTIDENTIFIER);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MAXIMUM_SUBSTITUTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_SUBSTITUTIONS);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_WEIGHTEDAVERAGELOANAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGELOANAGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_BENCHMARK_PRICE_SOURCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BENCHMARK_PRICE_SOURCE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MINIMUMDENOMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUMDENOMINATION);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_PAYMENTFREQUENCYCALENDAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PAYMENTFREQUENCYCALENDAR);
  return _val;
}


SWIGINTERN VALUE
StipulationType_POOLS_MAXIMUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_MAXIMUM);
  return _val;
}


SWIGINTERN VALUE
StipulationType_SUBSTITUTIONS_FREQUENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_FREQUENCY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_BENCHMARKPRICESOURCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BENCHMARKPRICESOURCE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ABSOLUTEPREPAYMENTSPEED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ABSOLUTEPREPAYMENTSPEED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_BANKQUALIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BANKQUALIFIED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_YIELDRANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YIELDRANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_BARGAINCONDITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BARGAINCONDITIONS);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MONTHLYPREPAYMENTRATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MONTHLYPREPAYMENTRATE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_POOLSPERLOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLSPERLOT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CONSTANT_PREPAYMENT_YIELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_YIELD);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MINIMUM_DENOMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_DENOMINATION);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ALTERNATIVE_MINIMUM_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ALTERNATIVE_MINIMUM_TAX);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CUSTOMSTARTENDDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CUSTOMSTARTENDDATE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_TYPEOFREDEMPTIONVALUESARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TYPEOFREDEMPTIONVALUESARE);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_NUMBEROFPIECES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_NUMBEROFPIECES);
  return _val;
}


SWIGINTERN VALUE
StipulationType_AMT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AMT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CONSTANTPREPAYMENTPENALTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANTPREPAYMENTPENALTY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MAXIMUM_ORDER_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_ORDER_SIZE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_AUTOREINVESTMENTATRATEORBETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AUTOREINVESTMENTATRATEORBETTER);
  return _val;
}


SWIGINTERN VALUE
StipulationType_BARGAIN_CONDITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BARGAIN_CONDITIONS);
  return _val;
}


SWIGINTERN VALUE
StipulationType_GEOGRAPHICSANDRANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICSANDRANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_TYPE_OF_ROLL_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_ROLL_TRADE);
  return _val;
}


SWIGINTERN VALUE
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
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
StipulationType_WEIGHTED_AVERAGE_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_COUPON);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_STRUCTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_STRUCTURE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WHOLEPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WHOLEPOOL);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MARKET_SECTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MARKET_SECTOR);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MATURITY_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_RANGE);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_POOLSPERMILLION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLSPERMILLION);
  return _val;
}


SWIGINTERN VALUE
StipulationType_TRADE_VARIANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TRADE_VARIANCE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ISSUERSTICKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISSUERSTICKER);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PRICERANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRICERANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_LOOKBACK_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_LOOKBACK_DAYS);
  return _val;
}


SWIGINTERN VALUE
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
StipulationType_POOLS_PER_MILLION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_MILLION);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MINIMUMINCREMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUMINCREMENT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MATURITY_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR);
  return _val;
}


SWIGINTERN VALUE
StipulationType_RATINGSOURCEANDRANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_RATINGSOURCEANDRANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_AVERAGE_LOAN_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_LOAN_SIZE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PURPOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PURPOSE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ISO_CURRENCY_CODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISO_CURRENCY_CODE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_RESTRICTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_RESTRICTED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BROKER_SALES_CREDIT_OVERRIDE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WEIGHTEDAVERAGECOUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGECOUPON);
  return _val;
}


SWIGINTERN VALUE
StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ISSUESIZERANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ISSUESIZERANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_YEAR_OF_ISSUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YEAR_OF_ISSUE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WEIGHTEDAVERAGELIFECOUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTEDAVERAGELIFECOUPON);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PAYMENT_FREQUENCY_CALENDAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PAYMENT_FREQUENCY_CALENDAR);
  return _val;
}


SWIGINTERN VALUE
StipulationType_TRADERS_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TRADERS_CREDIT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MINIMUM_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_SUBSTITUTIONS_LEFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_LEFT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_POOLS_PER_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_TRADE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_TYPE_OF_REDEMPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_REDEMPTION);
  return _val;
}


SWIGINTERN VALUE
StipulationType_CONSTANT_PREPAYMENT_PENALTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_PENALTY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LOAN_AGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PRICE_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRICE_RANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_SUBSTITUTIONSFREQUENCYREPO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONSFREQUENCYREPO);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PRODUCTION_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRODUCTION_YEAR);
  return _val;
}


SWIGINTERN VALUE
StipulationType_SINGLEMONTHLYMORTALITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_SINGLEMONTHLYMORTALITY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_OF_BMA_PREPAYMENT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_OF_BMA_PREPAYMENT_CURVE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_EXPLICIT_LOT_IDENTIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_EXPLICIT_LOT_IDENTIFIER);
  return _val;
}


SWIGINTERN VALUE
StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_ABSOLUTE_PREPAYMENT_SPEED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MAXIMUMDENOMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUMDENOMINATION);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_VALUATION_DISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_VALUATION_DISCOUNT);
  return _val;
}


SWIGINTERN VALUE
StipulationType_YIELD_TO_MATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YIELD_TO_MATURITY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_WEIGHTED_AVERAGE_LIFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_POOLSMAXIMUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLSMAXIMUM);
  return _val;
}


SWIGINTERN VALUE
StipulationType_YIELD_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_YIELD_RANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_PRICING_FREQUENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_PRICING_FREQUENCY);
  return _val;
}


SWIGINTERN VALUE
StipulationType_POOLSPERTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_POOLSPERTRADE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MONTHLY_PREPAYMENT_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MONTHLY_PREPAYMENT_RATE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_COUPONRANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_COUPONRANGE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_MARKETSECTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_MARKETSECTOR);
  return _val;
}


SWIGINTERN VALUE
StipulationType_AVERAGE_FICO_SCORE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_FICO_SCORE);
  return _val;
}


SWIGINTERN VALUE
StipulationType_INSURED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_INSURED);
  return _val;
}


SWIGINTERN VALUE
StipulationType_BANK_QUALIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::StipulationType_BANK_QUALIFIED);
  return _val;
}


SWIGINTERN VALUE
PriceQuoteMethod_STANDARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_STANDARD);
  return _val;
}


SWIGINTERN VALUE
PriceQuoteMethod_PERCENT_OF_PAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_PERCENT_OF_PAR);
  return _val;
}


SWIGINTERN VALUE
PriceQuoteMethod_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INDEX);
  return _val;
}


SWIGINTERN VALUE
PriceQuoteMethod_INTEREST_RATE_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INTEREST_RATE_INDEX);
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_REQUIREDTAGMISSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REQUIREDTAGMISSING));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER));
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_INVALIDTAGNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALIDTAGNUMBER));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_COMPID_PROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMPID_PROBLEM));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_SENDINGTIMEACCURACYPROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SENDINGTIMEACCURACYPROBLEM));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_SIGNATURE_PROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SIGNATURE_PROBLEM));
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_UNDEFINEDTAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_UNDEFINEDTAG));
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_UNDEFINED_TAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_UNDEFINED_TAG));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_TAGAPPEARSMORETHANONCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGAPPEARSMORETHANONCE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
SessionRejectReason_INVALIDMSGTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALIDMSGTYPE));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_XMLVALIDATIONERROR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_XMLVALIDATIONERROR));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_DECRYPTIONPROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_DECRYPTIONPROBLEM));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_INCORRECTDATAFORMATFORVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECTDATAFORMATFORVALUE));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
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
SessionRejectReason_COMPIDPROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMPIDPROBLEM));
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_SIGNATUREPROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SIGNATUREPROBLEM));
  return _val;
}


SWIGINTERN VALUE
SessionRejectReason_DECRYPTION_PROBLEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_DECRYPTION_PROBLEM));
  return _val;
}


SWIGINTERN VALUE
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
SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE));
  return _val;
}


SWIGINTERN VALUE
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
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
SessionRejectReason_INVALID_MSGTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_MSGTYPE));
  return _val;
}


SWIGINTERN VALUE
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
DeliveryType_TRI_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_TRI_PARTY));
  return _val;
}


SWIGINTERN VALUE
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
DeliveryType_FREE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_FREE));
  return _val;
}


SWIGINTERN VALUE
DeliveryType_HOLDINCUSTODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_HOLDINCUSTODY));
  return _val;
}


SWIGINTERN VALUE
DeliveryType_VERSUSPAYMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_VERSUSPAYMENT));
  return _val;
}


SWIGINTERN VALUE
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
DeliveryType_FREE_DELIVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_FREE_DELIVER));
  return _val;
}


SWIGINTERN VALUE
DeliveryType_TRIPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeliveryType_TRIPARTY));
  return _val;
}


SWIGINTERN VALUE
Scope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
Scope_LOCAL_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL_MARKET));
  return _val;
}


SWIGINTERN VALUE
Scope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
Scope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
Scope_LOCALMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Scope_LOCALMARKET));
  return _val;
}


SWIGINTERN VALUE
DeleteReason_CANCELLATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELLATION));
  return _val;
}


SWIGINTERN VALUE
DeleteReason_CANCELTRADEBUST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELTRADEBUST));
  return _val;
}


SWIGINTERN VALUE
DeleteReason_CANCELATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELATION));
  return _val;
}


SWIGINTERN VALUE
DeleteReason_ERROR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DeleteReason_ERROR));
  return _val;
}


SWIGINTERN VALUE
InViewOfCommon_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_NO));
  return _val;
}


SWIGINTERN VALUE
InViewOfCommon_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_YES));
  return _val;
}


SWIGINTERN VALUE
NoSides_BOTHSIDES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NoSides_BOTHSIDES));
  return _val;
}


SWIGINTERN VALUE
NoSides_ONESIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NoSides_ONESIDE));
  return _val;
}


SWIGINTERN VALUE
NoSides_ONE_SIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NoSides_ONE_SIDE));
  return _val;
}


SWIGINTERN VALUE
NoSides_BOTH_SIDES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NoSides_BOTH_SIDES));
  return _val;
}


SWIGINTERN VALUE
SecurityType_TERM_LIQUIDITY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TERM_LIQUIDITY_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TO_BE_ANNOUNCED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TO_BE_ANNOUNCED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVERSE_REPURCHASE_AGREEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVERSE_REPURCHASE_AGREEMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BRADY_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BRADY_BOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORP_MORTGAGE_BACKED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CERTIFICATE_OF_PARTICIPATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_PARTICIPATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BUY_SELLBACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BUY_SELLBACK);
  return _val;
}


SWIGINTERN VALUE
SecurityType_OPTIONS_ON_COMBO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_COMBO);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MULTILEG_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MULTILEG_INSTRUMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAX_ALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_ALLOCATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_US_TREASURY_NOTE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_BOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVENUE_ANTICIPATION_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_ANTICIPATION_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_YANKEECERTIFICATEOFDEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_YANKEECERTIFICATEOFDEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MEDIUMTERMNOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MEDIUMTERMNOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SPECIAL_TAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_TAX);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PRIVATE_EXPORT_FUNDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PRIVATE_EXPORT_FUNDING);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EUROCERTIFICATEOFDEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EUROCERTIFICATEOFDEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SPECIAL_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FX_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FX_SWAP);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVOLVER_TERM_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_TERM_LOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAXEXEMPTCOMMERCIALPAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAXEXEMPTCOMMERCIALPAPER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVOLVER_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_LOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CASH);
  return _val;
}


SWIGINTERN VALUE
SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MISCELLANEOUS_PASS_THRU_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THRU);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CONVERTIBLEBOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CONVERTIBLEBOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_VARIABLE_RATE_DEMAND_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_VARIABLE_RATE_DEMAND_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MULTILEGINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MULTILEGINSTRUMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SPECIALOBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIALOBLIGATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CANADIAN_TREASURY_BILLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_BILLS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVENUEANTICIPATIONNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVENUEANTICIPATIONNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CERTIFICATEOFOBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATEOFOBLIGATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_INDEXEDLINKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_INDEXEDLINKED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_LETTER_OF_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_LETTER_OF_CREDIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MANDATORYTENDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MANDATORYTENDER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_USTREASURYBOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYBOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TERMLOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TERMLOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_OPTIONS_ON_FUTURES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_FUTURES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PROMISSORYNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PROMISSORYNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_DUAL_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DUAL_CURRENCY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_WILDCARD_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD_ENTRY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BANK_DEPOSITORY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANK_DEPOSITORY_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REPLACED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REPLACED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGE_PRINCIPAL_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPAL_ONLY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CANADIAN_TREASURY_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_NOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TOBEANNOUNCED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TOBEANNOUNCED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SECURITIES_PLEDGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_PLEDGE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_YANKEE_CORPORATE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CORPORATE_BOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FX_SPOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FX_SPOT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_LIQUIDITYNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_LIQUIDITYNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_OVERNIGHT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OVERNIGHT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGE_INTEREST_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_INTEREST_ONLY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BRIDGELOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BRIDGELOAN);
  return _val;
}


SWIGINTERN VALUE
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
SecurityType_EXTENDED_COMM_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EXTENDED_COMM_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CERTIFICATEOFPARTICIPATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATEOFPARTICIPATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CATS_TIGERS_LIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CATS_TIGERS_LIONS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FORWARD);
  return _val;
}


SWIGINTERN VALUE
SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PREFERRED_STOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PREFERRED_STOCK);
  return _val;
}


SWIGINTERN VALUE
SecurityType_US_TREASURY_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BUYSELLBACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BUYSELLBACK);
  return _val;
}


SWIGINTERN VALUE
SecurityType_OPTIONS_ON_PHYSICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_PHYSICAL);
  return _val;
}


SWIGINTERN VALUE
SecurityType_ASSETBACKEDSECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_ASSETBACKEDSECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_NON_DELIVERABLE_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_NON_DELIVERABLE_FORWARD);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGE_PRINCIPLE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPLE_ONLY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGE_IOETTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_IOETTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_USD_SUPRANATIONAL_COUPONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USD_SUPRANATIONAL_COUPONS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_WARRANT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WARRANT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FOREIGN_EXCHANGE_CONTRACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FOREIGN_EXCHANGE_CONTRACT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FOREIGNEXCHANGECONTRACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FOREIGNEXCHANGECONTRACT);
  return _val;
}


SWIGINTERN VALUE
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
SecurityType_SPECIAL_ASSESSMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_ASSESSMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EUROSUPRANATIONALCOUPONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EUROSUPRANATIONALCOUPONS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_DEBTOR_IN_POSSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEBTOR_IN_POSSESSION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CANADIAN_MONEY_MARKETS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MONEY_MARKETS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGEPRINCIPALONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEPRINCIPALONLY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_USTREASURYNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_DEBTORINPOSSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEBTORINPOSSESSION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVENUEBONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVENUEBONDS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGEINTERESTONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEINTERESTONLY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_DEPOSITNOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEPOSITNOTES);
  return _val;
}


SWIGINTERN VALUE
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
SecurityType_MORTGAGEPRIVATEPLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEPRIVATEPLACEMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_NO_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_NO_SECURITY_TYPE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SPECIALASSESSMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIALASSESSMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_LETTEROFCREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_LETTEROFCREDIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAXALLOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAXALLOCATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAXABLE_MUNICIPAL_CP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAXABLE_MUNICIPAL_CP);
  return _val;
}


SWIGINTERN VALUE
SecurityType_OPTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OPTION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_NOSECURITYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_NOSECURITYTYPE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PROMISSORY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PROMISSORY_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_DUALCURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DUALCURRENCY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CREDIT_DEFAULT_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CREDIT_DEFAULT_SWAP);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAXANTICIPATIONNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAXANTICIPATIONNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRIVATE_PLACEMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_GENERAL_OBLIGATION_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_GENERAL_OBLIGATION_BONDS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SHORTTERMLOANNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SHORTTERMLOANNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_COMMERCIAL_PAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIAL_PAPER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGE_BACKED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_BACKED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EURO_SOVEREIGNS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_SOVEREIGNS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_REVENUE_ANTICIPATION_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PFANDBRIEFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PFANDBRIEFE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_OTHER_ANTICIPATION_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OTHER_ANTICIPATION_NOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PRIVATEEXPORTFUNDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PRIVATEEXPORTFUNDING);
  return _val;
}


SWIGINTERN VALUE
SecurityType_OTHERANTICIPATIONNOTESBANGANETC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_OTHERANTICIPATIONNOTESBANGANETC);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAX_ANTICIPATION_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAX_ANTICIPATION_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TREASURY_BILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_BILL);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PLAZOS_FIJOS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PLAZOS_FIJOS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EURO_COMMERCIAL_PAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_COMMERCIAL_PAPER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MANDATORY_TENDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MANDATORY_TENDER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PREFERREDSTOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PREFERREDSTOCK);
  return _val;
}


SWIGINTERN VALUE
SecurityType_VARIABLERATEDEMANDNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_VARIABLERATEDEMANDNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_DEFAULTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEFAULTED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_INDEXED_LINKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_INDEXED_LINKED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_IOETTE_MORTGAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_IOETTE_MORTGAGE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CERTIFICATE_OF_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BILLOFEXCHANGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BILLOFEXCHANGES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EUROSOVEREIGNS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EUROSOVEREIGNS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TIME_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TIME_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CORPORATEBOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORPORATEBOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FX_FORWARD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FX_FORWARD);
  return _val;
}


SWIGINTERN VALUE
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
SecurityType_US_TREASURY_NOTE_TNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_TNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MORTGAGEBACKEDSECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGEBACKEDSECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_DEPOSIT_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_DEPOSIT_NOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CORPORATEPRIVATEPLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORPORATEPRIVATEPLACEMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FEDERAL_HOUSING_AUTHORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOUSING_AUTHORITY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MATURED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MATURED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SWINGLINEFACILITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SWINGLINEFACILITY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MULTI_LEG_INSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MULTI_LEG_INSTRUMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CANADIAN_PROVINCIAL_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_PROVINCIAL_BONDS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MEDIUM_TERM_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MEDIUM_TERM_NOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_RETIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_RETIRED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MUTUAL_FUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MUTUAL_FUND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SECURITIESPLEDGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURITIESPLEDGE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_COMMERCIALPAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIALPAPER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REPURCHASE_AGREEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE_AGREEMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BILL_OF_EXCHANGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BILL_OF_EXCHANGES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MUTUALFUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MUTUALFUND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EXTENDEDCOMMNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EXTENDEDCOMMNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FEDERAL_HOME_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOME_LOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVOLVERLOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVOLVERLOAN);
  return _val;
}


SWIGINTERN VALUE
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
SecurityType_STRUCTURED_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_STRUCTURED_NOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_INTERESTSTRIPFROMANYBONDORNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_INTERESTSTRIPFROMANYBONDORNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CANADIAN_MORTGAGE_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MORTGAGE_BONDS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REPURCHASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_AGENCY_POOLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_AGENCY_POOLS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EURO_CORPORATE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_BOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SWING_LINE_FACILITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SWING_LINE_FACILITY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_USDSUPRANATIONALCOUPONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USDSUPRANATIONALCOUPONS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVOLVERTERMLOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVOLVERTERMLOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_LIQUIDITY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_LIQUIDITY_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MISCELLANEOUSPASSTHROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUSPASSTHROUGH);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CONVERTIBLE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CONVERTIBLE_BOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_ASSET_BACKED_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_ASSET_BACKED_SECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_WILDCARDENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WILDCARDENTRY);
  return _val;
}


SWIGINTERN VALUE
SecurityType_YANKEECORPORATEBOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_YANKEECORPORATEBOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TAXREVENUEANTICIPATIONNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TAXREVENUEANTICIPATIONNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BRADYBOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BRADYBOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_USTREASURYBILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_USTREASURYBILL);
  return _val;
}


SWIGINTERN VALUE
SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EUROCORPORATEBOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EUROCORPORATEBOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FUTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FUTURE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_US_TREASURY_BILL_TBILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_TBILL);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_CERTIFICATE_OF_DEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BANKERS_ACCEPTANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANKERS_ACCEPTANCE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_AMENDEDRESTATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_AMENDEDRESTATED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TERM_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TERM_LOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BANKNOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANKNOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SHORT_TERM_LOAN_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SHORT_TERM_LOAN_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_AMENDED_RESTATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_AMENDED_RESTATED);
  return _val;
}


SWIGINTERN VALUE
SecurityType_INTEREST_RATE_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_RATE_SWAP);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EUROCOMMERCIALPAPER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EUROCOMMERCIALPAPER);
  return _val;
}


SWIGINTERN VALUE
SecurityType_US_TREASURY_NOTE_UST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_UST);
  return _val;
}


SWIGINTERN VALUE
SecurityType_US_TREASURY_BILL_USTB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_USTB);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION);
  return _val;
}


SWIGINTERN VALUE
SecurityType_WITHDRAWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_WITHDRAWN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CORPORATE_PRIVATE_PLACEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_PRIVATE_PLACEMENT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CERTIFICATE_OF_OBLIGATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_OBLIGATION);
  return _val;
}


SWIGINTERN VALUE
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
SecurityType_STRUCTUREDNOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_STRUCTUREDNOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BANKERSACCEPTANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANKERSACCEPTANCE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_NO_ISITC_SECURITY_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_NO_ISITC_SECURITY_TYPE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CALLLOANS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CALLLOANS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MISCELLANEOUS_PASS_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THROUGH);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FEDERAL_AGENCY_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_COUPON);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CORPORATE_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_BOND);
  return _val;
}


SWIGINTERN VALUE
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
SecurityType_CORPMORTGAGEBACKEDSECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CORPMORTGAGEBACKEDSECURITIES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_EURO_SUPRANATIONAL_COUPONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_EURO_SUPRANATIONAL_COUPONS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CALL_LOANS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CALL_LOANS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_CERTIFICATEOFDEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATEOFDEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SECURED_LIQUIDITY_NOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURED_LIQUIDITY_NOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_TIMEDEPOSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_TIMEDEPOSIT);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BANK_NOTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BANK_NOTES);
  return _val;
}


SWIGINTERN VALUE
SecurityType_US_TREASURY_BILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL);
  return _val;
}


SWIGINTERN VALUE
SecurityType_GENERALOBLIGATIONBONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_GENERALOBLIGATIONBONDS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_COMMONSTOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COMMONSTOCK);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PLAZOSFIJOS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PLAZOSFIJOS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SECURITIES_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_LOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SECURITIESLOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SECURITIESLOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_MUNICIPAL_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_MUNICIPAL_BOND);
  return _val;
}


SWIGINTERN VALUE
SecurityType_REVENUE_BONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_BONDS);
  return _val;
}


SWIGINTERN VALUE
SecurityType_SPECIALTAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_SPECIALTAX);
  return _val;
}


SWIGINTERN VALUE
SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_BRIDGE_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_BRIDGE_LOAN);
  return _val;
}


SWIGINTERN VALUE
SecurityType_IOETTEMORTGAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_IOETTEMORTGAGE);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FEDERALAGENCYCOUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERALAGENCYCOUPON);
  return _val;
}


SWIGINTERN VALUE
SecurityType_COMMON_STOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_COMMON_STOCK);
  return _val;
}


SWIGINTERN VALUE
SecurityType_FEDERALAGENCYDISCOUNTNOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityType_FEDERALAGENCYDISCOUNTNOTE);
  return _val;
}


SWIGINTERN VALUE
RoundingDirection_ROUNDUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUNDUP));
  return _val;
}


SWIGINTERN VALUE
RoundingDirection_ROUND_DOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_DOWN));
  return _val;
}


SWIGINTERN VALUE
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
RoundingDirection_ROUND_UP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_UP));
  return _val;
}


SWIGINTERN VALUE
RoundingDirection_ROUNDDOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUNDDOWN));
  return _val;
}


SWIGINTERN VALUE
RoundingDirection_ROUNDNEAREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUNDNEAREST));
  return _val;
}


SWIGINTERN VALUE
TimeUnit_MINUTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_MINUTE);
  return _val;
}


SWIGINTERN VALUE
TimeUnit_WEEK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_WEEK);
  return _val;
}


SWIGINTERN VALUE
TimeUnit_SECOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_SECOND);
  return _val;
}


SWIGINTERN VALUE
TimeUnit_MONTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_MONTH);
  return _val;
}


SWIGINTERN VALUE
TimeUnit_HOUR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_HOUR);
  return _val;
}


SWIGINTERN VALUE
TimeUnit_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_DAY);
  return _val;
}


SWIGINTERN VALUE
TimeUnit_YEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TimeUnit_YEAR);
  return _val;
}


SWIGINTERN VALUE
LegSwapType_MODIFIED_DURATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_MODIFIED_DURATION));
  return _val;
}


SWIGINTERN VALUE
LegSwapType_PARFORPAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PARFORPAR));
  return _val;
}


SWIGINTERN VALUE
LegSwapType_RISK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_RISK));
  return _val;
}


SWIGINTERN VALUE
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
LegSwapType_MODIFIEDDURATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_MODIFIEDDURATION));
  return _val;
}


SWIGINTERN VALUE
LegSwapType_PROCEEDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PROCEEDS));
  return _val;
}


SWIGINTERN VALUE
IOITransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOITransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
IOITransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOITransType_NEW));
  return _val;
}


SWIGINTERN VALUE
IOITransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOITransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED));
  return _val;
}


SWIGINTERN VALUE
PosReqResult_VALID_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_VALID_REQUEST));
  return _val;
}


SWIGINTERN VALUE
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
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
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
PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS));
  return _val;
}


SWIGINTERN VALUE
PosReqResult_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_OTHER));
  return _val;
}


SWIGINTERN VALUE
PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA));
  return _val;
}


SWIGINTERN VALUE
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
PosReqResult_INVALIDORUNSUPPORTEDREQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_INVALIDORUNSUPPORTEDREQUEST));
  return _val;
}


SWIGINTERN VALUE
PosReqResult_VALIDREQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqResult_VALIDREQUEST));
  return _val;
}


SWIGINTERN VALUE
SettlInstMode_ACCOUNTOVERRIDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_ACCOUNTOVERRIDING));
  return _val;
}


SWIGINTERN VALUE
SettlInstMode_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_REJECT));
  return _val;
}


SWIGINTERN VALUE
SettlInstMode_DEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_DEFAULT));
  return _val;
}


SWIGINTERN VALUE
SettlInstMode_REQUEST_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_REQUEST_REJECT));
  return _val;
}


SWIGINTERN VALUE
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
SettlInstMode_SIPROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SIPROVIDED));
  return _val;
}


SWIGINTERN VALUE
SettlInstMode_ACCOUNTSTANDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_ACCOUNTSTANDING));
  return _val;
}


SWIGINTERN VALUE
SettlInstMode_CIVORDERSINGLEACCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_CIVORDERSINGLEACCT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
PreviouslyReported_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_NO));
  return _val;
}


SWIGINTERN VALUE
PreviouslyReported_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_YES));
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_PEGGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PEGGED);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_MARKET_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_SCALE);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_FILL_OR_KILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_FILL_OR_KILL);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ALL_OR_NONE);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_DIRECTED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DIRECTED_ORDER);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_OVER_THE_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OVER_THE_DAY);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_ADD_ON_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ADD_ON_ORDER);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_MARKET_AT_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_CLOSE);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_LIMIT_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_CASH_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CASH_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_MARKET_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_TIME_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TIME_ORDER);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_LIMIT_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_TRAILING_STOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRAILING_STOP);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_WORK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_WORK);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_RESERVE_SIZE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_RESERVE_SIZE_ORDER);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_MINIMUM_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MINIMUM_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_MARKET_AT_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_OPEN);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_IMBALANCE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMBALANCE_ONLY);
  return _val;
}


SWIGINTERN VALUE
CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
SecurityStatus_INACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityStatus_INACTIVE);
  return _val;
}


SWIGINTERN VALUE
SecurityStatus_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SecurityStatus_ACTIVE);
  return _val;
}


SWIGINTERN VALUE
ProcessCode_SOFT_DOLLAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_STEPOUTSOFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPOUTSOFT));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_STEPOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPOUT));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_PLAN_SPONSOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_PLAN_SPONSOR));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_STEP_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_IN));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_STEPIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPIN));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_REGULAR));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_SOFTDOLLAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFTDOLLAR));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_PLANSPONSOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_PLANSPONSOR));
  return _val;
}


SWIGINTERN VALUE
ProcessCode_STEPINSOFT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEPINSOFT));
  return _val;
}


SWIGINTERN VALUE
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
ProcessCode_STEP_OUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_OUT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
ExecInst_PARTICIPANT_DONT_INITIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTICIPANT_DONT_INITIATE));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_NO_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NO_CROSS));
  return _val;
}


SWIGINTERN VALUE
ExecInst_PEGVWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEGVWAP));
  return _val;
}


SWIGINTERN VALUE
ExecInst_STRICT_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_SCALE));
  return _val;
}


SWIGINTERN VALUE
ExecInst_AON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_AON));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_TRAILSTOPPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRAILSTOPPEG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_MARKPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKPEG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_MIDPRCPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_MIDPRCPEG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_OKCROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OKCROSS));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_CUSTDISPINST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CUSTDISPINST));
  return _val;
}


SWIGINTERN VALUE
ExecInst_IGNOREPRICECHK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_IGNOREPRICECHK));
  return _val;
}


SWIGINTERN VALUE
ExecInst_STRICTLIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICTLIMIT));
  return _val;
}


SWIGINTERN VALUE
ExecInst_WORKTOSTRATEGY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORKTOSTRATEGY));
  return _val;
}


SWIGINTERN VALUE
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
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
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
ExecInst_GO_ALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_GO_ALONG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_INSTITONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITONLY));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_SUSPEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND));
  return _val;
}


SWIGINTERN VALUE
ExecInst_TRYTOSTOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSTOP));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecInst_INTERMARKET_SWEEP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_INTERMARKET_SWEEP));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecInst_LASTPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_LASTPEG));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_PRIMARY_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMARY_PEG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_NONNEGO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NONNEGO));
  return _val;
}


SWIGINTERN VALUE
ExecInst_BEST_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_BEST_EXECUTION));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_NOTHELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOTHELD));
  return _val;
}


SWIGINTERN VALUE
ExecInst_STRICTSCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICTSCALE));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_DNI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNI));
  return _val;
}


SWIGINTERN VALUE
ExecInst_TRYTOSCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSCALE));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_GOALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_GOALONG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_WORK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK));
  return _val;
}


SWIGINTERN VALUE
ExecInst_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_HELD));
  return _val;
}


SWIGINTERN VALUE
ExecInst_NOCROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOCROSS));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_STRICT_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_LIMIT));
  return _val;
}


SWIGINTERN VALUE
ExecInst_OPENPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENPEG));
  return _val;
}


SWIGINTERN VALUE
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
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
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
ExecInst_RESTATEONTRADINGHALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONTRADINGHALT));
  return _val;
}


SWIGINTERN VALUE
ExecInst_INSTITUTIONS_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITUTIONS_ONLY));
  return _val;
}


SWIGINTERN VALUE
ExecInst_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOT_HELD));
  return _val;
}


SWIGINTERN VALUE
ExecInst_CANCELONTRADINGHALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONTRADINGHALT));
  return _val;
}


SWIGINTERN VALUE
ExecInst_CANCELONSYSFAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONSYSFAIL));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_MARKET_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKET_PEG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_TRADEALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADEALONG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_CALL_FIRST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALL_FIRST));
  return _val;
}


SWIGINTERN VALUE
ExecInst_PEGTOLIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEGTOLIMIT));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecInst_NON_NEGOTIABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NON_NEGOTIABLE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
ExecInst_OVERDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OVERDAY));
  return _val;
}


SWIGINTERN VALUE
ExecInst_LAST_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_LAST_PEG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_CALLFIRST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALLFIRST));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
ExecInst_OPENING_PEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENING_PEG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_PERCVOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PERCVOL));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
ExecInst_PARTNOTINIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTNOTINIT));
  return _val;
}


SWIGINTERN VALUE
ExecInst_CXLIFNOTBEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_CXLIFNOTBEST));
  return _val;
}


SWIGINTERN VALUE
ExecInst_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_NETTING));
  return _val;
}


SWIGINTERN VALUE
ExecInst_IMBALANCE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_IMBALANCE_ONLY));
  return _val;
}


SWIGINTERN VALUE
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
ExecInst_TRADE_ALONG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADE_ALONG));
  return _val;
}


SWIGINTERN VALUE
ExecInst_DNR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNR));
  return _val;
}


SWIGINTERN VALUE
ExecInst_STAYOFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYOFFER));
  return _val;
}


SWIGINTERN VALUE
ExecInst_STAYBID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYBID));
  return _val;
}


SWIGINTERN VALUE
ExecInst_RESTATEONSYSFAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONSYSFAIL));
  return _val;
}


SWIGINTERN VALUE
ExecInst_PRIMPEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMPEG));
  return _val;
}


SWIGINTERN VALUE
ExecType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
ExecType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_NEW));
  return _val;
}


SWIGINTERN VALUE
ExecType_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
ExecType_PENDINGNEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDINGNEW));
  return _val;
}


SWIGINTERN VALUE
ExecType_ORDERSTATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_ORDERSTATUS));
  return _val;
}


SWIGINTERN VALUE
ExecType_PENDING_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_CANCEL));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecType_ORDER_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_ORDER_STATUS));
  return _val;
}


SWIGINTERN VALUE
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
ExecType_PARTIAL_FILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PARTIAL_FILL));
  return _val;
}


SWIGINTERN VALUE
ExecType_PENDINGCXL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDINGCXL));
  return _val;
}


SWIGINTERN VALUE
ExecType_PENDING_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_NEW));
  return _val;
}


SWIGINTERN VALUE
ExecType_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_STOPPED));
  return _val;
}


SWIGINTERN VALUE
ExecType_CANCELED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELED));
  return _val;
}


SWIGINTERN VALUE
ExecType_PENDING_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_REPLACE));
  return _val;
}


SWIGINTERN VALUE
ExecType_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE));
  return _val;
}


SWIGINTERN VALUE
ExecType_TRADE_CORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CORRECT));
  return _val;
}


SWIGINTERN VALUE
ExecType_PENDINGREPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDINGREPLACE));
  return _val;
}


SWIGINTERN VALUE
ExecType_SUSPENDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_SUSPENDED));
  return _val;
}


SWIGINTERN VALUE
ExecType_FILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_FILL));
  return _val;
}


SWIGINTERN VALUE
ExecType_DONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_DONE));
  return _val;
}


SWIGINTERN VALUE
ExecType_RESTATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_RESTATED));
  return _val;
}


SWIGINTERN VALUE
ExecType_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_REJECTED));
  return _val;
}


SWIGINTERN VALUE
ExecType_REPLACED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACED));
  return _val;
}


SWIGINTERN VALUE
ExecType_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
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
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
ExecType_TRADECORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADECORRECT));
  return _val;
}


SWIGINTERN VALUE
ExecType_TRADECANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADECANCEL));
  return _val;
}


SWIGINTERN VALUE
ExecType_TRADE_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CANCEL));
  return _val;
}


SWIGINTERN VALUE
ExecType_CANCELLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELLED));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
EventType_TENDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_TENDER));
  return _val;
}


SWIGINTERN VALUE
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
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
EventType_ACTIVATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_ACTIVATION));
  return _val;
}


SWIGINTERN VALUE
EventType_PUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_PUT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
EventType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_OTHER));
  return _val;
}


SWIGINTERN VALUE
EventType_INACTIVIATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_INACTIVIATION));
  return _val;
}


SWIGINTERN VALUE
EventType_SINKINGFUNDCALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_SINKINGFUNDCALL));
  return _val;
}


SWIGINTERN VALUE
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
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
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
EventType_CALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::EventType_CALL));
  return _val;
}


SWIGINTERN VALUE
TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED));
  return _val;
}


SWIGINTERN VALUE
TradeAllocIndicator_ALLOCATION_REQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_REQUIRED));
  return _val;
}


SWIGINTERN VALUE
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
TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE));
  return _val;
}


SWIGINTERN VALUE
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
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
TradeAllocIndicator_ALLOCATIONNOTREQUIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATIONNOTREQUIRED));
  return _val;
}


SWIGINTERN VALUE
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
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
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
UserStatus_PASSWORD_INCORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_INCORRECT));
  return _val;
}


SWIGINTERN VALUE
UserStatus_USERNOTRECOGNISED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_USERNOTRECOGNISED));
  return _val;
}


SWIGINTERN VALUE
UserStatus_LOGGED_IN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_LOGGED_IN));
  return _val;
}


SWIGINTERN VALUE
UserStatus_PASSWORDCHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORDCHANGED));
  return _val;
}


SWIGINTERN VALUE
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
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
UserStatus_NOTLOGGEDIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_NOTLOGGEDIN));
  return _val;
}


SWIGINTERN VALUE
UserStatus_PASSWORD_CHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_CHANGED));
  return _val;
}


SWIGINTERN VALUE
UserStatus_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_OTHER));
  return _val;
}


SWIGINTERN VALUE
UserStatus_LOGGEDIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_LOGGEDIN));
  return _val;
}


SWIGINTERN VALUE
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
UserStatus_PASSWORDINCORRECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORDINCORRECT));
  return _val;
}


SWIGINTERN VALUE
InstrRegistry_PHYSICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::InstrRegistry_PHYSICAL);
  return _val;
}


SWIGINTERN VALUE
InstrRegistry_COUNTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::InstrRegistry_COUNTRY);
  return _val;
}


SWIGINTERN VALUE
InstrRegistry_CUSTODIAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::InstrRegistry_CUSTODIAN);
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_WEEKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_WEEKS));
  return _val;
}


SWIGINTERN VALUE
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
OrderDelayUnit_SECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_SECONDS));
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_MONTHS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MONTHS));
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_YEARS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_YEARS));
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_NANOSECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_NANOSECONDS));
  return _val;
}


SWIGINTERN VALUE
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
OrderDelayUnit_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HOURS));
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_MICROSECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MICROSECONDS));
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_MINUTES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MINUTES));
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_MILLISECONDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MILLISECONDS));
  return _val;
}


SWIGINTERN VALUE
OrderDelayUnit_DAYS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_DAYS));
  return _val;
}


SWIGINTERN VALUE
TradedFlatSwitch_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_NO));
  return _val;
}


SWIGINTERN VALUE
TradedFlatSwitch_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_YES));
  return _val;
}


SWIGINTERN VALUE
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
TrdRptStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
TrdRptStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_CANCELEDDUETOLOCKMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELEDDUETOLOCKMARKET));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_REJ_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REJ));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_LOCKEDMARKETWARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_LOCKEDMARKETWARNING));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_CROSSMARKETWARNING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CROSSMARKETWARNING));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_REMOVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REMOVED));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_CXLUNDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLUNDER));
  return _val;
}


SWIGINTERN VALUE
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
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
QuoteStatus_QUOTENOTFOUND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUOTENOTFOUND));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_CANCELED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED));
  return _val;
}


SWIGINTERN VALUE
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
QuoteStatus_CXLSYM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLSYM));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
QuoteStatus_ACCPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACCPT));
  return _val;
}


SWIGINTERN VALUE
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
QuoteStatus_CANCELED_ALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_ALL));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_PASS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PASS));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_CANCELEDDUETOCROSSMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELEDDUETOCROSSMARKET));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_QUERY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUERY));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_CXLSECTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLSECTYPE));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
QuoteStatus_EXPIRED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_EXPIRED));
  return _val;
}


SWIGINTERN VALUE
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
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
QuoteStatus_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACTIVE));
  return _val;
}


SWIGINTERN VALUE
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
QuoteStatus_CXLALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CXLALL));
  return _val;
}


SWIGINTERN VALUE
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
SolicitedFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_NO));
  return _val;
}


SWIGINTERN VALUE
SolicitedFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_YES));
  return _val;
}


SWIGINTERN VALUE
RiskLimitType_GROSS_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_GROSS_LIMIT));
  return _val;
}


SWIGINTERN VALUE
RiskLimitType_SHORT_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_SHORT_LIMIT));
  return _val;
}


SWIGINTERN VALUE
RiskLimitType_LONG_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_LONG_LIMIT));
  return _val;
}


SWIGINTERN VALUE
RiskLimitType_NET_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_NET_LIMIT));
  return _val;
}


SWIGINTERN VALUE
RiskLimitType_EXPOSURE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RiskLimitType_EXPOSURE));
  return _val;
}


SWIGINTERN VALUE
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
ShortSaleReason_DEALERSOLDSHORTEXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALERSOLDSHORTEXEMPT));
  return _val;
}


SWIGINTERN VALUE
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
ShortSaleReason_DEALERSOLDSHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALERSOLDSHORT));
  return _val;
}


SWIGINTERN VALUE
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
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
ShortSaleReason_SELLINGCUSTOMERSOLDSHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLINGCUSTOMERSOLDSHORT));
  return _val;
}


SWIGINTERN VALUE
ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT));
  return _val;
}


SWIGINTERN VALUE
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
ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT));
  return _val;
}


SWIGINTERN VALUE
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
ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT));
  return _val;
}


SWIGINTERN VALUE
PegRoundDirection_MOREPASSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MOREPASSIVE));
  return _val;
}


SWIGINTERN VALUE
PegRoundDirection_MOREAGGRESSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MOREAGGRESSIVE));
  return _val;
}


SWIGINTERN VALUE
PegRoundDirection_MORE_AGGRESSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_AGGRESSIVE));
  return _val;
}


SWIGINTERN VALUE
PegRoundDirection_MORE_PASSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_PASSIVE));
  return _val;
}


SWIGINTERN VALUE
ModelType_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ModelType_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
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
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
FuturesValuationMethod_PREMIUM_STYLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FuturesValuationMethod_PREMIUM_STYLE);
  return _val;
}


SWIGINTERN VALUE
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
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
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
ConfirmStatus_CONFIRMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_CONFIRMED));
  return _val;
}


SWIGINTERN VALUE
ConfirmStatus_REQUESTREJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_REQUESTREJECTED));
  return _val;
}


SWIGINTERN VALUE
ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS));
  return _val;
}


SWIGINTERN VALUE
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
ConfirmStatus_REQUEST_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_REQUEST_REJECTED));
  return _val;
}


SWIGINTERN VALUE
ConfirmStatus_MISMATCHEDACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISMATCHEDACCOUNT));
  return _val;
}


SWIGINTERN VALUE
ConfirmStatus_MISMATCHED_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISMATCHED_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
ConfirmStatus_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
LocateReqd_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LocateReqd_NO));
  return _val;
}


SWIGINTERN VALUE
LocateReqd_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LocateReqd_YES));
  return _val;
}


SWIGINTERN VALUE
Adjustment_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Adjustment_CANCEL));
  return _val;
}


SWIGINTERN VALUE
Adjustment_CORRECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Adjustment_CORRECTION));
  return _val;
}


SWIGINTERN VALUE
Adjustment_ERROR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Adjustment_ERROR));
  return _val;
}


SWIGINTERN VALUE
StreamAsgnType_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_ASSIGNMENT));
  return _val;
}


SWIGINTERN VALUE
StreamAsgnType_TERMINATE_UNASSIGN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_TERMINATE_UNASSIGN));
  return _val;
}


SWIGINTERN VALUE
StreamAsgnType_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_REJECTED));
  return _val;
}


SWIGINTERN VALUE
LastRptRequested_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_NO));
  return _val;
}


SWIGINTERN VALUE
LastRptRequested_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_YES));
  return _val;
}


SWIGINTERN VALUE
SettlSessID_END_OF_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_END_OF_DAY);
  return _val;
}


SWIGINTERN VALUE
SettlSessID_REGULAR_TRADING_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_REGULAR_TRADING_HOURS);
  return _val;
}


SWIGINTERN VALUE
SettlSessID_ELECTRONIC_TRADING_HOURS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_ELECTRONIC_TRADING_HOURS);
  return _val;
}


SWIGINTERN VALUE
SettlSessID_INTRADAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlSessID_INTRADAY);
  return _val;
}


SWIGINTERN VALUE
TradeReportType_NO_WAS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NO_WAS));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_ADDENDUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ADDENDUM));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_7_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_7));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_PENDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_PENDED));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_LOCKEDINTRADEBREAK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_LOCKEDINTRADEBREAK));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_DEFAULTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DEFAULTED));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_DECLINE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DECLINE));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_ALLEGED_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NEW));
  return _val;
}


SWIGINTERN VALUE
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
TradeReportType_ALLEGED_15_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_15));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_ALLEGED_ADDENDUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_ADDENDUM));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_ALLEGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_SUBMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_SUBMIT));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_NOWAS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NOWAS));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_ALLEGED_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_1));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_INVALID_CMTA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_INVALID_CMTA));
  return _val;
}


SWIGINTERN VALUE
TradeReportType_TRADEREPORTCANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_TRADEREPORTCANCEL));
  return _val;
}


SWIGINTERN VALUE
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
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
TradeReportType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
ExerciseStyle_AMERICAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_AMERICAN));
  return _val;
}


SWIGINTERN VALUE
ExerciseStyle_EUROPEAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_EUROPEAN));
  return _val;
}


SWIGINTERN VALUE
ExerciseStyle_BERMUDA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_BERMUDA));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_EQUIPCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_EQUIPCHANGE));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_ADDITIONAL_INFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ADDITIONAL_INFORMATION));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_ORDINFL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDINFL));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_NEW_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEW_PENDING));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_NEWSDISS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWSDISS));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_PENDING));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_ORDER_INFLUX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_INFLUX));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_DISSEMINATION));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_ADDINFO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ADDINFO));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_ORDIMB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDIMB));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_EQUIPMENT_CHANGEOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_EQUIPMENT_CHANGEOVER));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_ORDER_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_IMBALANCE));
  return _val;
}


SWIGINTERN VALUE
HaltReasonChar_NEWSPEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWSPEND));
  return _val;
}


SWIGINTERN VALUE
ExDestination_POSIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestination_POSIT));
  return _val;
}


SWIGINTERN VALUE
ExDestination_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExDestination_NONE));
  return _val;
}


SWIGINTERN VALUE
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
AllocReportType_WAREHOUSE_RECAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_WAREHOUSE_RECAP));
  return _val;
}


SWIGINTERN VALUE
AllocReportType_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REJECT));
  return _val;
}


SWIGINTERN VALUE
AllocReportType_REQUESTTOINTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REQUESTTOINTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
AllocReportType_ACCEPT_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT_PENDING));
  return _val;
}


SWIGINTERN VALUE
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
AllocReportType_COMPLETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_COMPLETE));
  return _val;
}


SWIGINTERN VALUE
AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
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
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
AllocReportType_REVERSE_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REVERSE_PENDING));
  return _val;
}


SWIGINTERN VALUE
AllocReportType_WAREHOUSERECAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_WAREHOUSERECAP));
  return _val;
}


SWIGINTERN VALUE
AllocReportType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
AllocType_BUYSIDEREADYTOBOOKSINGLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDEREADYTOBOOKSINGLE));
  return _val;
}


SWIGINTERN VALUE
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
AllocType_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
AllocType_INCOMPLETE_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_INCOMPLETE_GROUP));
  return _val;
}


SWIGINTERN VALUE
AllocType_REVERSAL_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_REVERSAL_PENDING));
  return _val;
}


SWIGINTERN VALUE
AllocType_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
AllocType_REJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_REJECT));
  return _val;
}


SWIGINTERN VALUE
AllocType_WAREHOUSEINSTRUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_WAREHOUSEINSTRUCTION));
  return _val;
}


SWIGINTERN VALUE
AllocType_BUYSIDEPRELIM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDEPRELIM));
  return _val;
}


SWIGINTERN VALUE
AllocType_REQUESTTOINTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_REQUESTTOINTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
AllocType_ACCEPT_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT_PENDING));
  return _val;
}


SWIGINTERN VALUE
AllocType_BUYSIDEREADYTOBOOKCOMBINED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDEREADYTOBOOKCOMBINED));
  return _val;
}


SWIGINTERN VALUE
AllocType_BUYSIDE_CALCULATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_CALCULATED));
  return _val;
}


SWIGINTERN VALUE
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
AllocType_SELLSIDECALCWITHOUTPRELIM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDECALCWITHOUTPRELIM));
  return _val;
}


SWIGINTERN VALUE
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
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
AllocType_COMPLETE_GROUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_COMPLETE_GROUP));
  return _val;
}


SWIGINTERN VALUE
AllocType_BUYSIDECALC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDECALC));
  return _val;
}


SWIGINTERN VALUE
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
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
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
AllocType_WAREHOUSE_INSTRUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_WAREHOUSE_INSTRUCTION));
  return _val;
}


SWIGINTERN VALUE
AllocType_BUYSIDE_PRELIMINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_PRELIMINARY));
  return _val;
}


SWIGINTERN VALUE
AllocType_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
AllocType_SELLSIDECALC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDECALC));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INSUFFICIENT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_NOMARKETFORINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOMARKETFORINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_NOTAUTHTOREQQUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOTAUTHTOREQQUOTE));
  return _val;
}


SWIGINTERN VALUE
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
QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_INVALID_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INVALID_PRICE));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_EXCHANGECLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCHANGECLOSED));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_TOOLATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_TOOLATE));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_INVPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INVPRICE));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_NOMATCHFORINQUIRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOMATCHFORINQUIRY));
  return _val;
}


SWIGINTERN VALUE
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
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
QuoteRequestRejectReason_UNKNOWNSYM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_UNKNOWNSYM));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_EXCHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCHANGE));
  return _val;
}


SWIGINTERN VALUE
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
QuoteRequestRejectReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_PASS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_PASS));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_NOINVENTORY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOINVENTORY));
  return _val;
}


SWIGINTERN VALUE
QuoteRequestRejectReason_NO_INVENTORY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_INVENTORY));
  return _val;
}


SWIGINTERN VALUE
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
LiquidityIndType_5DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_5DAY));
  return _val;
}


SWIGINTERN VALUE
LiquidityIndType_NORMAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_NORMAL));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
LiquidityIndType_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_OTHER));
  return _val;
}


SWIGINTERN VALUE
LiquidityIndType_20DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_20DAY));
  return _val;
}


SWIGINTERN VALUE
StatusValue_IN_PROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_IN_PROCESS));
  return _val;
}


SWIGINTERN VALUE
StatusValue_NOTCONNECTEDDOWNEXPECTEDUP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOTCONNECTEDDOWNEXPECTEDUP));
  return _val;
}


SWIGINTERN VALUE
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
StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN));
  return _val;
}


SWIGINTERN VALUE
StatusValue_CONNECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_CONNECTED));
  return _val;
}


SWIGINTERN VALUE
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
StatusValue_INPROCESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StatusValue_INPROCESS));
  return _val;
}


SWIGINTERN VALUE
PosType_INTRA_SPREAD_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTRA_SPREAD_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_INTER_SPREAD_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTER_SPREAD_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSFER_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSFER_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_EXCHANGE_FOR_PHYSICAL_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_EXCHANGE_FOR_PHYSICAL_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSFERTRADEQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSFERTRADEQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSACTIONQUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTIONQUANTITY);
  return _val;
}


SWIGINTERN VALUE
PosType_ADJUSTMENTQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ADJUSTMENTQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_START_OF_DAY_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_START_OF_DAY_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_ENDOFDAYQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ENDOFDAYQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_DELIVERY_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_DELIVERY_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSACTIONFROMEXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTIONFROMEXERCISE);
  return _val;
}


SWIGINTERN VALUE
PosType_OPTIONEXERCISEQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_OPTIONEXERCISEQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_DELIVERYQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_DELIVERYQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_OPTION_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_OPTION_ASSIGNMENT);
  return _val;
}


SWIGINTERN VALUE
PosType_PIT_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_PIT_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSACTION_FROM_ASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_ASSIGNMENT);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSACTION_FROM_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_EXERCISE);
  return _val;
}


SWIGINTERN VALUE
PosType_INTEGRALSPLIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTEGRALSPLIT);
  return _val;
}


SWIGINTERN VALUE
PosType_ELECTRONICTRADEQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ELECTRONICTRADEQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_AS_OF_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_AS_OF_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_ELECTRONIC_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ELECTRONIC_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_PITTRADEQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_PITTRADEQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_OPTIONASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_OPTIONASSIGNMENT);
  return _val;
}


SWIGINTERN VALUE
PosType_SUCCESSION_EVENT_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_SUCCESSION_EVENT_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
PosType_OPTION_EXERCISE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_OPTION_EXERCISE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSACTION_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
PosType_NET_DELTA_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_NET_DELTA_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_END_OF_DAY_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_END_OF_DAY_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_ADJUSTMENT_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ADJUSTMENT_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TOTAL_TRANSACTION_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TOTAL_TRANSACTION_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_DELIVERY_NOTICE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_DELIVERY_NOTICE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_RECEIVE_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_RECEIVE_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
PosType_ASOFTRADEQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ASOFTRADEQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_ALLOCATIONTRADEQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ALLOCATIONTRADEQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_CREDIT_EVENT_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_CREDIT_EVENT_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_PRIVATELY_NEGOTIATED_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_CROSS_MARGIN_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_CROSS_MARGIN_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_CORPORATE_ACTION_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_CORPORATE_ACTION_ADJUSTMENT);
  return _val;
}


SWIGINTERN VALUE
PosType_TOTALTRANSACTIONQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TOTALTRANSACTIONQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_STARTOFDAYQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_STARTOFDAYQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_INTEGRAL_SPLIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTEGRAL_SPLIT);
  return _val;
}


SWIGINTERN VALUE
PosType_INTERSPREADQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTERSPREADQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_INTRASPREADQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_INTRASPREADQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_ALLOCATION_TRADE_QTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_ALLOCATION_TRADE_QTY);
  return _val;
}


SWIGINTERN VALUE
PosType_CROSSMARGINQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_CROSSMARGINQTY);
  return _val;
}


SWIGINTERN VALUE
PosType_TRANSACTIONFROMASSIGNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PosType_TRANSACTIONFROMASSIGNMENT);
  return _val;
}


SWIGINTERN VALUE
StreamAsgnAckType_ASSIGNMENT_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_REJECTED));
  return _val;
}


SWIGINTERN VALUE
StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
RiskInstrumentOperator_EXCLUDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RiskInstrumentOperator_EXCLUDE));
  return _val;
}


SWIGINTERN VALUE
RiskInstrumentOperator_INCLUDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RiskInstrumentOperator_INCLUDE));
  return _val;
}


SWIGINTERN VALUE
MiscFeeBasis_PERUNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PERUNIT));
  return _val;
}


SWIGINTERN VALUE
MiscFeeBasis_ABSOLUTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_ABSOLUTE));
  return _val;
}


SWIGINTERN VALUE
MiscFeeBasis_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
MiscFeeBasis_PER_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PER_UNIT));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREX_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_MARKET));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_ONBASIS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_ONBASIS));
  return _val;
}


SWIGINTERN VALUE
OrdType_PREVIOUSLYINDICATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLYINDICATED));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_PEGGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PEGGED));
  return _val;
}


SWIGINTERN VALUE
OrdType_LIMITONCLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMITONCLOSE));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_STOP_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP_LIMIT));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREX_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_SWAP));
  return _val;
}


SWIGINTERN VALUE
OrdType_WITHORWITHOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_WITHORWITHOUT));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREXLIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXLIMIT));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_PREVIOUSLYQUOTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLYQUOTED));
  return _val;
}


SWIGINTERN VALUE
OrdType_PREVIOUSLY_QUOTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_QUOTED));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_LIMITWITHORWITHOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMITWITHORWITHOUT));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREXSWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXSWAP));
  return _val;
}


SWIGINTERN VALUE
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
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
OrdType_FOREX_C_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_C));
  return _val;
}


SWIGINTERN VALUE
OrdType_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_CLOSE));
  return _val;
}


SWIGINTERN VALUE
OrdType_STOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP));
  return _val;
}


SWIGINTERN VALUE
OrdType_STOPLIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_STOPLIMIT));
  return _val;
}


SWIGINTERN VALUE
OrdType_LIMITORBETTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMITORBETTER));
  return _val;
}


SWIGINTERN VALUE
OrdType_ONCLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_ONCLOSE));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREX_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_LIMIT));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREXMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXMARKET));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX));
  return _val;
}


SWIGINTERN VALUE
OrdType_MARKETIFTOUCHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKETIFTOUCHED));
  return _val;
}


SWIGINTERN VALUE
OrdType_FUNARI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FUNARI));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREX_F_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_F));
  return _val;
}


SWIGINTERN VALUE
OrdType_PREVIOUSLY_INDICATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_INDICATED));
  return _val;
}


SWIGINTERN VALUE
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
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
OrdType_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_FOREX_G_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_G));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_MARKETONCLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKETONCLOSE));
  return _val;
}


SWIGINTERN VALUE
OrdType_PREVIOUSFUNDVALUATIONPOINT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSFUNDVALUATIONPOINT));
  return _val;
}


SWIGINTERN VALUE
OrdType_NEXTFUNDVALUATIONPOINT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_NEXTFUNDVALUATIONPOINT));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREX_H_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_H));
  return _val;
}


SWIGINTERN VALUE
OrdType_FOREXPREVIOUSLYQUOTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREXPREVIOUSLYQUOTED));
  return _val;
}


SWIGINTERN VALUE
OrdType_MARKETWITHLEFTOVERLIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKETWITHLEFTOVERLIMIT));
  return _val;
}


SWIGINTERN VALUE
OrdType_ON_BASIS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_BASIS));
  return _val;
}


SWIGINTERN VALUE
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
OrdType_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET));
  return _val;
}


SWIGINTERN VALUE
MatchType_ACT_DEFAULT_AFTER_M2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_AFTER_M2);
  return _val;
}


SWIGINTERN VALUE
MatchType_SUMMARIZEDMATCHUSINGA2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA2);
  return _val;
}


SWIGINTERN VALUE
MatchType_COUNTER_ORDER_SELECTION_6_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_6);
  return _val;
}


SWIGINTERN VALUE
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
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
MatchType_NON_ACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NON_ACT);
  return _val;
}


SWIGINTERN VALUE
MatchType_SUMMARIZEDMATCHUSINGA3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA3);
  return _val;
}


SWIGINTERN VALUE
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
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
MatchType_SUMMARIZEDMATCHUSINGA4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA4);
  return _val;
}


SWIGINTERN VALUE
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
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
MatchType_SUMMARIZEDMATCHUSINGA5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA5);
  return _val;
}


SWIGINTERN VALUE
MatchType_NASDAQACTM2MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTM2MATCH);
  return _val;
}


SWIGINTERN VALUE
MatchType_CROSS_AUCTION_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_5);
  return _val;
}


SWIGINTERN VALUE
MatchType_ACT_M1_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_M1_MATCH);
  return _val;
}


SWIGINTERN VALUE
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
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
MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES);
  return _val;
}


SWIGINTERN VALUE
MatchType_NASDAQACTDEFAULTAFTERM2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTDEFAULTAFTERM2);
  return _val;
}


SWIGINTERN VALUE
MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES);
  return _val;
}


SWIGINTERN VALUE
MatchType_NASDAQACTM1MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTM1MATCH);
  return _val;
}


SWIGINTERN VALUE
MatchType_CALL_AUCTION_7_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_7);
  return _val;
}


SWIGINTERN VALUE
MatchType_CROSS_AUCTION_63_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_63);
  return _val;
}


SWIGINTERN VALUE
MatchType_ISSUING_BUY_BACK_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ISSUING_BUY_BACK_AUCTION);
  return _val;
}


SWIGINTERN VALUE
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
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
MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME);
  return _val;
}


SWIGINTERN VALUE
MatchType_ONE_PARTY_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_ACT_M2_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_M2_MATCH);
  return _val;
}


SWIGINTERN VALUE
MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES);
  return _val;
}


SWIGINTERN VALUE
MatchType_NASDAQACTDEFAULTTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTDEFAULTTRADE);
  return _val;
}


SWIGINTERN VALUE
MatchType_CALL_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_ACT_ACCEPTED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_ACCEPTED_TRADE);
  return _val;
}


SWIGINTERN VALUE
MatchType_TWO_PARTY_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_CONTINUOUS_AUTO_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CONTINUOUS_AUTO_MATCH);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_ACT_M6_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_M6_MATCH);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_ACT_DEFAULT_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_TRADE);
  return _val;
}


SWIGINTERN VALUE
MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_AUTO_MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_AUTO_MATCH);
  return _val;
}


SWIGINTERN VALUE
MatchType_NASDAQACTM6MATCH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTM6MATCH);
  return _val;
}


SWIGINTERN VALUE
MatchType_OCSLOCKEDIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_OCSLOCKEDIN);
  return _val;
}


SWIGINTERN VALUE
MatchType_COUNTER_ORDER_SELECTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION);
  return _val;
}


SWIGINTERN VALUE
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
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
MatchType_NASDAQACTACCEPTEDTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NASDAQACTACCEPTEDTRADE);
  return _val;
}


SWIGINTERN VALUE
MatchType_CALL_AUCTION_65_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_65);
  return _val;
}


SWIGINTERN VALUE
MatchType_CROSS_AUCTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_CONFIRMED_TRADE_REPORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_CONFIRMED_TRADE_REPORT);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME);
  return _val;
}


SWIGINTERN VALUE
MatchType_NASDAQNONACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_NASDAQNONACT);
  return _val;
}


SWIGINTERN VALUE
MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS);
  return _val;
}


SWIGINTERN VALUE
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
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
MatchType_SUMMARIZEDMATCHUSINGA1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZEDMATCHUSINGA1);
  return _val;
}


SWIGINTERN VALUE
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
MatchType_COUNTER_ORDER_SELECTION_64_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_64);
  return _val;
}


SWIGINTERN VALUE
OptPayoutType_BINARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_BINARY));
  return _val;
}


SWIGINTERN VALUE
OptPayoutType_VANILLA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_VANILLA));
  return _val;
}


SWIGINTERN VALUE
OptPayoutType_CAPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_CAPPED));
  return _val;
}


SWIGINTERN VALUE
MarketUpdateAction_DELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_DELETE));
  return _val;
}


SWIGINTERN VALUE
MarketUpdateAction_ADD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_ADD));
  return _val;
}


SWIGINTERN VALUE
MarketUpdateAction_MODIFY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_MODIFY));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION));
  return _val;
}


SWIGINTERN VALUE
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
CollAsgnRejectReason_UNKNOWNDEAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWNDEAL));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_UNKNOWN_DEAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_DEAL));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION));
  return _val;
}


SWIGINTERN VALUE
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
CollAsgnRejectReason_INSUFFICIENTCOLLATERAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INSUFFICIENTCOLLATERAL));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INSUFFICIENT_COLLATERAL));
  return _val;
}


SWIGINTERN VALUE
CollAsgnRejectReason_EXCESSIVESUBSTITUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_EXCESSIVESUBSTITUTION));
  return _val;
}


SWIGINTERN VALUE
IndividualAllocType_SUB_ALLOCATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_SUB_ALLOCATE));
  return _val;
}


SWIGINTERN VALUE
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
GTBookingInst_ACCUMUNTILFILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMUNTILFILL));
  return _val;
}


SWIGINTERN VALUE
GTBookingInst_ACCUMUNTILNOTIFY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMUNTILNOTIFY));
  return _val;
}


SWIGINTERN VALUE
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
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
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
GTBookingInst_BOOKALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_BOOKALL));
  return _val;
}


SWIGINTERN VALUE
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
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
PutOrCall_PUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PutOrCall_PUT));
  return _val;
}


SWIGINTERN VALUE
PutOrCall_CALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PutOrCall_CALL));
  return _val;
}


SWIGINTERN VALUE
FundRenewWaiv_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_NO));
  return _val;
}


SWIGINTERN VALUE
FundRenewWaiv_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_YES));
  return _val;
}


SWIGINTERN VALUE
ForexReq_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ForexReq_NO));
  return _val;
}


SWIGINTERN VALUE
ForexReq_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ForexReq_YES));
  return _val;
}


SWIGINTERN VALUE
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
TickRuleType_REGULAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_REGULAR));
  return _val;
}


SWIGINTERN VALUE
TickRuleType_VARIABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_VARIABLE));
  return _val;
}


SWIGINTERN VALUE
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
TickRuleType_FIXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TickRuleType_FIXED));
  return _val;
}


SWIGINTERN VALUE
DiscretionOffsetType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE));
  return _val;
}


SWIGINTERN VALUE
DiscretionOffsetType_BASISPOINTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_BASISPOINTS));
  return _val;
}


SWIGINTERN VALUE
DiscretionOffsetType_PRICE_TIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE_TIER));
  return _val;
}


SWIGINTERN VALUE
DiscretionOffsetType_TICKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_TICKS));
  return _val;
}


SWIGINTERN VALUE
DiscretionOffsetType_PRICETIERLEVEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICETIERLEVEL));
  return _val;
}


SWIGINTERN VALUE
DiscretionOffsetType_BASIS_POINTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_BASIS_POINTS));
  return _val;
}


SWIGINTERN VALUE
ConfirmTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
ConfirmTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
ConfirmTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
MDSecSizeType_CUSTOMER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MDSecSizeType_CUSTOMER));
  return _val;
}


SWIGINTERN VALUE
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
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
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
TradSesEvent_TRADING_RESUMES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_TRADING_RESUMES));
  return _val;
}


SWIGINTERN VALUE
DlvyInstType_SECURITIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_SECURITIES));
  return _val;
}


SWIGINTERN VALUE
DlvyInstType_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_CASH));
  return _val;
}


SWIGINTERN VALUE
TradeCondition_IMPLIED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMPLIED_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CASHMKT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CASHMKT);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OPENING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_PRICE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_PRIOR_REFERENCE_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_PRIOR_REFERENCE_PRICE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_LAST_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SELLER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SELLER);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_DISTRIBUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_DISTRIBUTION);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_NEXT_DAY_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_STRADDLE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OPENINGPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENINGPRICE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CROSSED_AO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_AO);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SOLD_LAST_SALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OPENED_SALE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENED_SALE_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_REOPEN_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SOLD_LAST_SALE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_STOPPED_SOLD_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_SOLD_LAST);
  return _val;
}


SWIGINTERN VALUE
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
TradeCondition_NEXTDAY_D_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_NEXTDAY_D);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_FORM_T_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_FORM_T);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_ADJUSTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OUT_OF_SEQUENCE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OUT_OF_SEQUENCE_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_RULE127_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_RULE127);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_COMBO_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_COMBO_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_ONLY_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_STRADDLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OUTSIDE_SPREAD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OUTSIDE_SPREAD);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_BUNCHED_SALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED_SALE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_LATE_OPEN_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_LATE_OPEN_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_REOPENING_TRADE_DETAIL);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_COMBO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_COMBO);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OPENING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENING);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_ACQUISITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_ACQUISITION);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OPENED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OPENED);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_NEXT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_BARGAIN_CONDITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BARGAIN_CONDITION);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_STOPPED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CONVERTED_PRICE_INDICATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CONVERTED_PRICE_INDICATOR);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OFFICIAL_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OFFICIAL_CLOSING_PRICE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_ADJUSTED_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_AVGPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_AVGPX);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_RULE_155_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_RULE_155_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SOLDLAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLDLAST);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_NEXTDAY_J_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_NEXTDAY_J);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_AUTOMATIC_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_AUTOMATIC_EXECUTION);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CROSSED_X_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_X);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_AUTO_EXECUTION_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_AUTO_EXECUTION_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_MULTILEG_TO_MULTILEG_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_OFFICAL_CLOSING_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_OFFICAL_CLOSING_PRICE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_FINAL_PRICE_OF_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_FINAL_PRICE_OF_SESSION);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_BASKET_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BASKET_INDEX);
  return _val;
}


SWIGINTERN VALUE
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
TradeCondition_STOPPED_STOCK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_STOCK);
  return _val;
}


SWIGINTERN VALUE
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
TradeCondition_STOPPED_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_REGULAR_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_REGULAR_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CASH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CASHTRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CASHTRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_RULE155_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_RULE155);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_STOPPED_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_VOLUME_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_VOLUME_ONLY);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SPLIT_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SPLIT_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_STOPPED_OUT_OF_SEQUENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_OUT_OF_SEQUENCE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CASH_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CASH_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_IMBALANCE_MORE_BUYERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_BUYERS);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_BUNCHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_INTRADAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_INTRADAY);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_IMBALANCE_MORE_SELLERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_SELLERS);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_INTRADAY_TRADE_DETAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_INTRADAY_TRADE_DETAIL);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_RULE_127_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_RULE_127_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_IMBALANCEMOREBUYERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCEMOREBUYERS);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_REOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_EX_PIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_EX_PIT);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_DIRECT_PLUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_DIRECT_PLUS);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_IMBALANCEMORESELLERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCEMORESELLERS);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_AVERAGE_PRICE_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_AVERAGE_PRICE_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SOLD_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_MARKETPLACE_ENTERED_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_MARKETPLACE_ENTERED_TRADE);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SPREAD_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_CANCEL_OPEN_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN_ETH);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_EXCHANGE_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_EXCHANGE_LAST);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_FAST_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_FAST_MARKET);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_BURST_BASKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_BURST_BASKET);
  return _val;
}


SWIGINTERN VALUE
TradeCondition_SOLD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TradeCondition_SOLD);
  return _val;
}


SWIGINTERN VALUE
PriceLimitType_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PRICE));
  return _val;
}


SWIGINTERN VALUE
PriceLimitType_TICKS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_TICKS));
  return _val;
}


SWIGINTERN VALUE
PriceLimitType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
CommType_PER_SHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PER_SHARE));
  return _val;
}


SWIGINTERN VALUE
CommType_PCTWAIVEDCSHDISC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PCTWAIVEDCSHDISC));
  return _val;
}


SWIGINTERN VALUE
CommType_ABSOLUTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_ABSOLUTE));
  return _val;
}


SWIGINTERN VALUE
CommType_PCTWAIVEDENUNITS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PCTWAIVEDENUNITS));
  return _val;
}


SWIGINTERN VALUE
CommType_PERBOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PERBOND));
  return _val;
}


SWIGINTERN VALUE
CommType_PER_BOND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PER_BOND));
  return _val;
}


SWIGINTERN VALUE
CommType_PERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
CommType_PER_UNIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PER_UNIT));
  return _val;
}


SWIGINTERN VALUE
CommType_PERCENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENT));
  return _val;
}


SWIGINTERN VALUE
CommType_4_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_4));
  return _val;
}


SWIGINTERN VALUE
CommType_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CommType_5));
  return _val;
}


SWIGINTERN VALUE
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
RegistRejReasonCode_INVALIDOWNERSHIPTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDOWNERSHIPTYPE));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDREGDTLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDREGDTLS));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDMAILINGDTLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDMAILINGDTLS));
  return _val;
}


SWIGINTERN VALUE
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
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
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
RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
RegistRejReasonCode_INVALIDDATEOFBIRTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDDATEOFBIRTH));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD));
  return _val;
}


SWIGINTERN VALUE
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
RegistRejReasonCode_INVALIDNODISTRIBINSTNS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDNODISTRIBINSTNS));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDTAXEXEMPTTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDTAXEXEMPTTYPE));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDMAILINGINST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDMAILINGINST));
  return _val;
}


SWIGINTERN VALUE
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
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
RegistRejReasonCode_INVALIDACCOUNTTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDACCOUNTTYPE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
RegistRejReasonCode_INVALIDREGSEQNO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDREGSEQNO));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_OTHER));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
RegistRejReasonCode_INVALIDINVESTORIDSOURCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDINVESTORIDSOURCE));
  return _val;
}


SWIGINTERN VALUE
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
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
RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDNOREGDETLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDNOREGDETLS));
  return _val;
}


SWIGINTERN VALUE
RegistRejReasonCode_INVALIDINVESTORID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALIDINVESTORID));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
FinancialStatus_BANKRUPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_BANKRUPT));
  return _val;
}


SWIGINTERN VALUE
FinancialStatus_PENDINGDELISTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_PENDINGDELISTING));
  return _val;
}


SWIGINTERN VALUE
FinancialStatus_RESTRICTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_RESTRICTED));
  return _val;
}


SWIGINTERN VALUE
FinancialStatus_PENDING_DELISTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_PENDING_DELISTING));
  return _val;
}


SWIGINTERN VALUE
LastFragment_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastFragment_NO));
  return _val;
}


SWIGINTERN VALUE
LastFragment_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastFragment_YES));
  return _val;
}


SWIGINTERN VALUE
NotifyBrokerOfCredit_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_NO));
  return _val;
}


SWIGINTERN VALUE
NotifyBrokerOfCredit_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_YES));
  return _val;
}


SWIGINTERN VALUE
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
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
PartySubIDType_FAX_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FAX_NUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_CONTACTNAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTACTNAME));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_DEPARTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DEPARTMENT));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_CONTACT_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTACT_NAME));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_TELEXNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_TELEXNUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_PERSON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PERSON));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FIRM));
  return _val;
}


SWIGINTERN VALUE
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
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
PartySubIDType_POSTAL_ADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSTAL_ADDRESS));
  return _val;
}


SWIGINTERN VALUE
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
PartySubIDType_POSTALADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSTALADDRESS));
  return _val;
}


SWIGINTERN VALUE
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
PartySubIDType_PROFESSIONAL_CLIENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PROFESSIONAL_CLIENT));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_FULLLEGALNAMEOFFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FULLLEGALNAMEOFFIRM));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_LOCATIONDESK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATIONDESK));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_REGISTEREDADDRESS_12_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTEREDADDRESS_12));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_REGISTRATION_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_EMAILADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EMAILADDRESS));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_SYSTEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEM));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_SECURITIESACCOUNTNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIESACCOUNTNUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_REGULATORY_STATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGULATORY_STATUS));
  return _val;
}


SWIGINTERN VALUE
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
PartySubIDType_PHONENUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PHONENUMBER));
  return _val;
}


SWIGINTERN VALUE
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
PartySubIDType_REGISTRATION_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NAME));
  return _val;
}


SWIGINTERN VALUE
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
PartySubIDType_TELEX_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_TELEX_NUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_EMAIL_ADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EMAIL_ADDRESS));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_FAXNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FAXNUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_BIC));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_CASHACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASHACCOUNT));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_REGISTRATIONNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATIONNUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_LOCATION_DESK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION_DESK));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_APPLICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_APPLICATION));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_CASHACCOUNTNAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASHACCOUNTNAME));
  return _val;
}


SWIGINTERN VALUE
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
PartySubIDType_PHONE_NUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PHONE_NUMBER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_SECURITIESACCOUNTNAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIESACCOUNTNAME));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_REGISTRATIONNAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATIONNAME));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_ELIGIBLE_COUNTERPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ELIGIBLE_COUNTERPARTY));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_REGISTEREDADDRESS_18_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTEREDADDRESS_18));
  return _val;
}


SWIGINTERN VALUE
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
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
PartySubIDType_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_EXECUTION_VENUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EXECUTION_VENUE));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_POSITIONACCOUNTTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSITIONACCOUNTTYPE));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_FUNDACCOUNTNAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FUNDACCOUNTNAME));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_CSDPARTICIPANTMEMBERCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CSDPARTICIPANTMEMBERCODE));
  return _val;
}


SWIGINTERN VALUE
PartySubIDType_REGULATORYSTATUS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGULATORYSTATUS));
  return _val;
}


SWIGINTERN VALUE
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
AllocNoOrdersType_NOTSPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_NOTSPECIFIED));
  return _val;
}


SWIGINTERN VALUE
AllocNoOrdersType_NOT_SPECIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_NOT_SPECIFIED));
  return _val;
}


SWIGINTERN VALUE
AllocNoOrdersType_EXPLICITLISTPROVIDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_EXPLICITLISTPROVIDED));
  return _val;
}


SWIGINTERN VALUE
AllocLinkType_FX_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_SWAP));
  return _val;
}


SWIGINTERN VALUE
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
AllocLinkType_FXNETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FXNETTING));
  return _val;
}


SWIGINTERN VALUE
AllocLinkType_FX_NETTING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_NETTING));
  return _val;
}


SWIGINTERN VALUE
AllocLinkType_FXSWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FXSWAP));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
DisplayMethod_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_NEW));
  return _val;
}


SWIGINTERN VALUE
DisplayMethod_UNDISCLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_UNDISCLOSED));
  return _val;
}


SWIGINTERN VALUE
DisplayMethod_RANDOM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_RANDOM));
  return _val;
}


SWIGINTERN VALUE
DisplayMethod_INITIAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_INITIAL));
  return _val;
}


SWIGINTERN VALUE
CollStatus_PARTIALLY_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_PARTIALLY_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollStatus_ASSIGNEDACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNEDACCEPTED));
  return _val;
}


SWIGINTERN VALUE
CollStatus_ASSIGNMENT_PROPOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNMENT_PROPOSED));
  return _val;
}


SWIGINTERN VALUE
CollStatus_ASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollStatus_CHALLENGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_CHALLENGED));
  return _val;
}


SWIGINTERN VALUE
CollStatus_UNASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_UNASSIGNED));
  return _val;
}


SWIGINTERN VALUE
CollStatus_ASSIGNMENTPROPOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNMENTPROPOSED));
  return _val;
}


SWIGINTERN VALUE
CollStatus_PARTIALLYASSIGNED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollStatus_PARTIALLYASSIGNED));
  return _val;
}


SWIGINTERN VALUE
SideValueInd_SIDEVALUE_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE_2));
  return _val;
}


SWIGINTERN VALUE
SideValueInd_SIDEVALUE1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE1));
  return _val;
}


SWIGINTERN VALUE
SideValueInd_SIDEVALUE2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE2));
  return _val;
}


SWIGINTERN VALUE
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
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
MsgDirection_RECEIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MsgDirection_RECEIVE));
  return _val;
}


SWIGINTERN VALUE
MsgDirection_SEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MsgDirection_SEND));
  return _val;
}


SWIGINTERN VALUE
MDUpdateAction_DELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE));
  return _val;
}


SWIGINTERN VALUE
MDUpdateAction_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_NEW));
  return _val;
}


SWIGINTERN VALUE
MDUpdateAction_DELETE_THRU_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_THRU));
  return _val;
}


SWIGINTERN VALUE
MDUpdateAction_DELETE_FROM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_FROM));
  return _val;
}


SWIGINTERN VALUE
MDUpdateAction_OVERLAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_OVERLAY));
  return _val;
}


SWIGINTERN VALUE
MDUpdateAction_CHANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_CHANGE));
  return _val;
}


SWIGINTERN VALUE
MatchStatus_ADVALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MatchStatus_ADVALERT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
MatchStatus_UNCOMPUNMATUNAFF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MatchStatus_UNCOMPUNMATUNAFF));
  return _val;
}


SWIGINTERN VALUE
MatchStatus_COMPMATAFF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MatchStatus_COMPMATAFF));
  return _val;
}


SWIGINTERN VALUE
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
RateSource_REUTERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_REUTERS));
  return _val;
}


SWIGINTERN VALUE
RateSource_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_OTHER));
  return _val;
}


SWIGINTERN VALUE
RateSource_BLOOMBERG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_BLOOMBERG));
  return _val;
}


SWIGINTERN VALUE
RateSource_TELERATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RateSource_TELERATE));
  return _val;
}


SWIGINTERN VALUE
AllocPositionEffect_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_CLOSE));
  return _val;
}


SWIGINTERN VALUE
AllocPositionEffect_FIFO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_FIFO));
  return _val;
}


SWIGINTERN VALUE
AllocPositionEffect_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_OPEN));
  return _val;
}


SWIGINTERN VALUE
AllocPositionEffect_ROLLED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_ROLLED));
  return _val;
}


SWIGINTERN VALUE
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
PartyIDSource_PROPRIETARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPRIETARY));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_USEMPLOYERIDNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_USEMPLOYERIDNUMBER));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_ACCPTMARKETPART_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ACCPTMARKETPART));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_CSDPARTCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CSDPARTCODE));
  return _val;
}


SWIGINTERN VALUE
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
PartyIDSource_KOREANINVESTORID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_KOREANINVESTORID));
  return _val;
}


SWIGINTERN VALUE
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
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
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
PartyIDSource_AUSTRALIANTAXFILENUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIANTAXFILENUMBER));
  return _val;
}


SWIGINTERN VALUE
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
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
PartyIDSource_CHINESEBSHARE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CHINESEBSHARE));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_AUSTRALIANBUSINESSNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIANBUSINESSNUMBER));
  return _val;
}


SWIGINTERN VALUE
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
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
PartyIDSource_TAIWANESEQUALIFIED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESEQUALIFIED));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_USSOCIALSECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_USSOCIALSECURITY));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_DIRECTEDDEFINEDISITC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_DIRECTEDDEFINEDISITC));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
PartyIDSource_UKNATIONALINSPENNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_UKNATIONALINSPENNUMBER));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_BIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_BIC));
  return _val;
}


SWIGINTERN VALUE
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
PartyIDSource_TAIWANESETRADINGACCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESETRADINGACCT));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_MIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MIC));
  return _val;
}


SWIGINTERN VALUE
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
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
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
PartyIDSource_PROPCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPCODE));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_ISOCODE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ISOCODE));
  return _val;
}


SWIGINTERN VALUE
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
PartyIDSource_MCDNUMBER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MCDNUMBER));
  return _val;
}


SWIGINTERN VALUE
PartyIDSource_SETTLENTLOC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_SETTLENTLOC));
  return _val;
}


SWIGINTERN VALUE
ExchangeForPhysical_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_NO));
  return _val;
}


SWIGINTERN VALUE
ExchangeForPhysical_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_YES));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
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
SecurityTradingEvent_TRADING_RESUMES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_TRADING_RESUMES));
  return _val;
}


SWIGINTERN VALUE
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
CollAction_ADD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAction_ADD));
  return _val;
}


SWIGINTERN VALUE
CollAction_REMOVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAction_REMOVE));
  return _val;
}


SWIGINTERN VALUE
CollAction_RETAIN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CollAction_RETAIN));
  return _val;
}


SWIGINTERN VALUE
PossDupFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_NO));
  return _val;
}


SWIGINTERN VALUE
PossDupFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_YES));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_ALL_DONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALL_DONE));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_TIMED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_TIMED));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_RESP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_RESP));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_EXECSTARTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXECSTARTED));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_RESPONSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_RESPONSE));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_ALLDONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALLDONE));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALERT));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_ACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ACK));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_EXEC_STARTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXEC_STARTED));
  return _val;
}


SWIGINTERN VALUE
ListStatusType_EXECSTART_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXECSTART));
  return _val;
}


SWIGINTERN VALUE
GapFillFlag_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_NO));
  return _val;
}


SWIGINTERN VALUE
GapFillFlag_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_YES));
  return _val;
}


SWIGINTERN VALUE
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
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
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
TradeHandlingInstr_TRADE_CONFIRMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TRADE_CONFIRMATION));
  return _val;
}


SWIGINTERN VALUE
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
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
TradSesMethod_TWOPARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_TWOPARTY));
  return _val;
}


SWIGINTERN VALUE
TradSesMethod_ELECTRONIC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_ELECTRONIC));
  return _val;
}


SWIGINTERN VALUE
TradSesMethod_OPENOUTCRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_OPENOUTCRY));
  return _val;
}


SWIGINTERN VALUE
TradSesMethod_TWO_PARTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_TWO_PARTY));
  return _val;
}


SWIGINTERN VALUE
TradSesMethod_OPEN_OUTCRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_OPEN_OUTCRY));
  return _val;
}


SWIGINTERN VALUE
TradeType_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_AGENCY));
  return _val;
}


SWIGINTERN VALUE
TradeType_VWAP_GUARANTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_VWAP_GUARANTEE));
  return _val;
}


SWIGINTERN VALUE
TradeType_RISK_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_RISK_TRADE));
  return _val;
}


SWIGINTERN VALUE
TradeType_GUARANTEED_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::TradeType_GUARANTEED_CLOSE));
  return _val;
}


SWIGINTERN VALUE
ComplexEventCondition_AND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_AND));
  return _val;
}


SWIGINTERN VALUE
ComplexEventCondition_OR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_OR));
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_SONIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SONIA);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_MUNIAAA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_MUNIAAA);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_LIBID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBID);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_PFANDBRIEFE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_PFANDBRIEFE);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_EUREPO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EUREPO);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_FUTURESWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FUTURESWAP);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_TREASURY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TREASURY);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_OTHER);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_EURIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EURIBOR);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_EONIA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EONIA);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_LIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBOR);
  return _val;
}


SWIGINTERN VALUE
BenchmarkCurveName_SWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SWAP);
  return _val;
}


SWIGINTERN VALUE
CashMargin_MARGINCLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGINCLOSE));
  return _val;
}


SWIGINTERN VALUE
CashMargin_MARGINOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGINOPEN));
  return _val;
}


SWIGINTERN VALUE
CashMargin_MARGIN_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_CLOSE));
  return _val;
}


SWIGINTERN VALUE
CashMargin_MARGIN_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_OPEN));
  return _val;
}


SWIGINTERN VALUE
CashMargin_CASH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CashMargin_CASH));
  return _val;
}


SWIGINTERN VALUE
SettlObligTransType_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_REPLACE));
  return _val;
}


SWIGINTERN VALUE
SettlObligTransType_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_NEW));
  return _val;
}


SWIGINTERN VALUE
SettlObligTransType_RESTATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_RESTATE));
  return _val;
}


SWIGINTERN VALUE
SettlObligTransType_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_CANCEL));
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_PEGGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_PEGGED);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_MARKET_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_SCALE);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_FILL_OR_KILL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_FILL_OR_KILL);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_ALL_OR_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ALL_OR_NONE);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_DIRECTED_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_DIRECTED_ORDER);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_OVER_THE_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_OVER_THE_DAY);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_ADD_ON_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ADD_ON_ORDER);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_MARKET_AT_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_CLOSE);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_LIMIT_ON_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_OPEN);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_CASH_NOT_HELD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_CASH_NOT_HELD);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_MARKET_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_TIME_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TIME_ORDER);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_LIMIT_ON_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_CLOSE);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_TRAILING_STOP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TRAILING_STOP);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_WORK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_WORK);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_RESERVE_SIZE_ORDER);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_MINIMUM_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MINIMUM_QUANTITY);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_MARKET_AT_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_OPEN);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_IMBALANCE_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMBALANCE_ONLY);
  return _val;
}


SWIGINTERN VALUE
DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return _val;
}


SWIGINTERN VALUE
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
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
PosTransType_DONOTEXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_DONOTEXERCISE));
  return _val;
}


SWIGINTERN VALUE
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
PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION));
  return _val;
}


SWIGINTERN VALUE
PosTransType_POSITIONADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITIONADJUSTMENT));
  return _val;
}


SWIGINTERN VALUE
PosTransType_EXERCISE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_EXERCISE));
  return _val;
}


SWIGINTERN VALUE
PosTransType_POSITION_ADJUSTMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_ADJUSTMENT));
  return _val;
}


SWIGINTERN VALUE
PosTransType_PLEDGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosTransType_PLEDGE));
  return _val;
}


SWIGINTERN VALUE
Seniority_SUBORDINATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::Seniority_SUBORDINATED);
  return _val;
}


SWIGINTERN VALUE
Seniority_SENIOR_SECURED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::Seniority_SENIOR_SECURED);
  return _val;
}


SWIGINTERN VALUE
Seniority_SENIOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::Seniority_SENIOR);
  return _val;
}


SWIGINTERN VALUE
SettlCurrFxRateCalc_DIVIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_DIVIDE));
  return _val;
}


SWIGINTERN VALUE
SettlCurrFxRateCalc_MULTIPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_MULTIPLY));
  return _val;
}


SWIGINTERN VALUE
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
PosMaintStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
PosMaintStatus_ACCEPTEDWITHWARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTEDWITHWARNINGS));
  return _val;
}


SWIGINTERN VALUE
PosMaintStatus_COMPLETEDWITHWARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETEDWITHWARNINGS));
  return _val;
}


SWIGINTERN VALUE
PosMaintStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
PosMaintStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
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
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
Benchmark_OLD_5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_5));
  return _val;
}


SWIGINTERN VALUE
Benchmark_OLD_30_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_30));
  return _val;
}


SWIGINTERN VALUE
Benchmark_30YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_30YR));
  return _val;
}


SWIGINTERN VALUE
Benchmark_5YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_5YR));
  return _val;
}


SWIGINTERN VALUE
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
Benchmark_OLD_10_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_10));
  return _val;
}


SWIGINTERN VALUE
Benchmark_6MOLIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_6MOLIBOR));
  return _val;
}


SWIGINTERN VALUE
Benchmark_10YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_10YR));
  return _val;
}


SWIGINTERN VALUE
Benchmark_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_CURVE));
  return _val;
}


SWIGINTERN VALUE
Benchmark_30_YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_30_YR));
  return _val;
}


SWIGINTERN VALUE
Benchmark_10_YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_10_YR));
  return _val;
}


SWIGINTERN VALUE
Benchmark_5_YR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_5_YR));
  return _val;
}


SWIGINTERN VALUE
Benchmark_OLD30_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD30));
  return _val;
}


SWIGINTERN VALUE
Benchmark_OLD5_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD5));
  return _val;
}


SWIGINTERN VALUE
Benchmark_OLD10_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD10));
  return _val;
}


SWIGINTERN VALUE
Benchmark_3MOLIBOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Benchmark_3MOLIBOR));
  return _val;
}


SWIGINTERN VALUE
MaturityMonthYearFormat_YEARMONTHWEEK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHWEEK));
  return _val;
}


SWIGINTERN VALUE
MaturityMonthYearFormat_YEARMONTHDAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHDAY));
  return _val;
}


SWIGINTERN VALUE
MaturityMonthYearFormat_YEARMONTH_ONLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTH_ONLY));
  return _val;
}


SWIGINTERN VALUE
LegalConfirm_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_NO));
  return _val;
}


SWIGINTERN VALUE
LegalConfirm_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_YES));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
ReportToExch_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ReportToExch_NO));
  return _val;
}


SWIGINTERN VALUE
ReportToExch_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ReportToExch_YES));
  return _val;
}


SWIGINTERN VALUE
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
AllocRejCode_UNKNOWNACCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNACCT));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_INCORRECTAVGPRC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTAVGPRC));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_UNKNOWN_ORDERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ORDERID));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_WAREHOUSEREQUESTREJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_WAREHOUSEREQUESTREJECTED));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_UNKNOWNORSTALEEXECID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNORSTALEEXECID));
  return _val;
}


SWIGINTERN VALUE
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
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
AllocRejCode_MISMATCHEDDATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHEDDATA));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_INCORRECTBRKMNC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTBRKMNC));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_UNKNOWNLISTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNLISTID));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_OTHER_99_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_99));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_INCORRECTALLOCATEDQUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTALLOCATEDQUANTITY));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_UNKNOWN_LISTID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_LISTID));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_INCORRECT_QUANTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_QUANTITY));
  return _val;
}


SWIGINTERN VALUE
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
AllocRejCode_UNKNOWN_ACCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ACCOUNT));
  return _val;
}


SWIGINTERN VALUE
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
AllocRejCode_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_OTHER_7_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_7));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_UNKNOWN_CLORDID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_CLORDID));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_INCORRECTQTY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECTQTY));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_COMMDIFF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_COMMDIFF));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_CALCULATIONDIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_CALCULATIONDIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_UNKNOWNCLORDID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNCLORDID));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_UNKNOWNORDID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWNORDID));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_MISMATCHED_DATA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHED_DATA));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_CALCULATION_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_CALCULATION_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
AllocRejCode_COMMISSION_DIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_COMMISSION_DIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
RefOrdIDReason_ORDER_CHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_ORDER_CHANGED));
  return _val;
}


SWIGINTERN VALUE
RefOrderIDSource_SECONDARYORDERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDERID));
  return _val;
}


SWIGINTERN VALUE
RefOrderIDSource_ORDERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDERID));
  return _val;
}


SWIGINTERN VALUE
RefOrderIDSource_MDENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MDENTRYID));
  return _val;
}


SWIGINTERN VALUE
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
RefOrderIDSource_MENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MENTRYID));
  return _val;
}


SWIGINTERN VALUE
RefOrderIDSource_QUOTEENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTEENTRYID));
  return _val;
}


SWIGINTERN VALUE
RefOrderIDSource_QUOTENTRYID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTENTRYID));
  return _val;
}


SWIGINTERN VALUE
RefOrderIDSource_ORDEID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDEID));
  return _val;
}


SWIGINTERN VALUE
RefOrderIDSource_SECONDARYORDEID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDEID));
  return _val;
}


SWIGINTERN VALUE
LastCapacity_A_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_A));
  return _val;
}


SWIGINTERN VALUE
LastCapacity_XP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_XP));
  return _val;
}


SWIGINTERN VALUE
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
LastCapacity_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
LastCapacity_P_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_P));
  return _val;
}


SWIGINTERN VALUE
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
LastCapacity_AGENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_AGENT));
  return _val;
}


SWIGINTERN VALUE
LastCapacity_XA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LastCapacity_XA));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_IN_DEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_IN_DEFAULT));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_COUPONPERIOD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_COUPONPERIOD));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_PRE_REFUNDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRE_REFUNDED));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_CALLABLEPUTTABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLEPUTTABLE));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_STEPPEDCOUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_STEPPEDCOUPON));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_UNRATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_UNRATED));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_STEPPED_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_STEPPED_COUPON));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_TEXT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TEXT));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_ORIGINALISSUEDISCOUNTPRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINALISSUEDISCOUNTPRICE));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_ESCROWEDTOREDEMPTIONDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWEDTOREDEMPTIONDATE));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_INSTRUMENT_DENOMINATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_DENOMINATOR));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_INTEREST_BEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INTEREST_BEARING));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_TAXABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TAXABLE));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_CALLABLE_PUTTABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_PUTTABLE));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_COUPON_PERIOD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_COUPON_PERIOD));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_LESSFEEFORPUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_LESSFEEFORPUT));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_INTERESTBEARING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INTERESTBEARING));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_PREREFUNDED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PREREFUNDED));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_TRADEABLE_INDICATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADEABLE_INDICATOR));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_VARIABLE_RATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_VARIABLE_RATE));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_WHENISSUED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_WHENISSUED));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_ZEROCOUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ZEROCOUPON));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_ESCROWEDTOMATURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWEDTOMATURITY));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_FLAT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_FLAT));
  return _val;
}


SWIGINTERN VALUE
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
InstrAttribType_INSTRUMENT_NUMERATOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_NUMERATOR));
  return _val;
}


SWIGINTERN VALUE
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
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
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
InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_INDEXED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INDEXED));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_INDEFAULT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INDEFAULT));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_ZERO_COUPON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ZERO_COUPON));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_NOPERIODICPAYMENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_NOPERIODICPAYMENTS));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_CALLABLEBELOWMATURITYVALUE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLEBELOWMATURITYVALUE));
  return _val;
}


SWIGINTERN VALUE
InstrAttribType_ORIGINALISSUEDISCOUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINALISSUEDISCOUNT));
  return _val;
}


SWIGINTERN VALUE
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
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
InstrAttribType_VARIABLERATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_VARIABLERATE));
  return _val;
}


SWIGINTERN VALUE
Product_FINANCING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_FINANCING));
  return _val;
}


SWIGINTERN VALUE
Product_COMMODITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_COMMODITY));
  return _val;
}


SWIGINTERN VALUE
Product_EQUITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_EQUITY));
  return _val;
}


SWIGINTERN VALUE
Product_CORPORATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_CORPORATE));
  return _val;
}


SWIGINTERN VALUE
Product_AGENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_AGENCY));
  return _val;
}


SWIGINTERN VALUE
Product_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_OTHER));
  return _val;
}


SWIGINTERN VALUE
Product_MONEYMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_MONEYMARKET));
  return _val;
}


SWIGINTERN VALUE
Product_MORTGAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_MORTGAGE));
  return _val;
}


SWIGINTERN VALUE
Product_CURRENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_CURRENCY));
  return _val;
}


SWIGINTERN VALUE
Product_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_INDEX));
  return _val;
}


SWIGINTERN VALUE
Product_MUNICIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_MUNICIPAL));
  return _val;
}


SWIGINTERN VALUE
Product_LOAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_LOAN));
  return _val;
}


SWIGINTERN VALUE
Product_GOVERNMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::Product_GOVERNMENT));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_NOMKTIMB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOMKTIMB));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_NOOPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOOPEN));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_FAST_MARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_FAST_MARKET));
  return _val;
}


SWIGINTERN VALUE
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
SecurityTradingStatus_TRADING_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_HALT));
  return _val;
}


SWIGINTERN VALUE
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
SecurityTradingStatus_11_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_11));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_NO_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_OPEN));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_NOTTRADED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOTTRADED));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_FASTMARKET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_FASTMARKET));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_MKTBALSELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTBALSELL));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_NEWPXIND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NEWPXIND));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_TRDDISTIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRDDISTIME));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_PXIND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PXIND));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_CROSS));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_OPENINGROTATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENINGROTATION));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_TRDRNGIND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRDRNGIND));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_RESUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_RESUME));
  return _val;
}


SWIGINTERN VALUE
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
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
SecurityTradingStatus_POST_CLOSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_POST_CLOSE));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_OPENDELAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENDELAY));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_READY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_READY));
  return _val;
}


SWIGINTERN VALUE
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
SecurityTradingStatus_NOTAVAIL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOTAVAIL));
  return _val;
}


SWIGINTERN VALUE
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
SecurityTradingStatus_OPENING_DELAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_DELAY));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_MKTONCLSIMBSELL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTONCLSIMBSELL));
  return _val;
}


SWIGINTERN VALUE
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
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
SecurityTradingStatus_PRE_CROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_CROSS));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_NA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NA));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_NOMKTONCLSIMB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOMKTONCLSIMB));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_PRE_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_OPEN));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
SecurityTradingStatus_ITSPREOPN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_ITSPREOPN));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_TRDHALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRDHALT));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_MKTONCLSIMBBUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTONCLSIMBBUY));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_OPENING_ROTATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_ROTATION));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_PRICE_INDICATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRICE_INDICATION));
  return _val;
}


SWIGINTERN VALUE
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
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
SecurityTradingStatus_UNKNOWN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_UNKNOWN));
  return _val;
}


SWIGINTERN VALUE
SecurityTradingStatus_MKTIMBBUY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MKTIMBBUY));
  return _val;
}


SWIGINTERN VALUE
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
Rule80A_PRGINDEXARBOTHMEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBOTHMEM));
  return _val;
}


SWIGINTERN VALUE
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
Rule80A_SPECIALIST_TRADES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SPECIALIST_TRADES));
  return _val;
}


SWIGINTERN VALUE
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
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
Rule80A_SHTEXTRANI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANI));
  return _val;
}


SWIGINTERN VALUE
Rule80A_SHTEXTRANMEMWT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANMEMWT));
  return _val;
}


SWIGINTERN VALUE
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
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
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
Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING));
  return _val;
}


SWIGINTERN VALUE
Rule80A_SHTEXTRANMEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANMEM));
  return _val;
}


SWIGINTERN VALUE
Rule80A_PRGINDEXARBOTHAGN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBOTHAGN));
  return _val;
}


SWIGINTERN VALUE
Rule80A_PRGNONINDEXARBINV_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBINV));
  return _val;
}


SWIGINTERN VALUE
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
Rule80A_PRINCIPAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRINCIPAL));
  return _val;
}


SWIGINTERN VALUE
Rule80A_AGENCY_INDEX_ARBITRAGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_INDEX_ARBITRAGE));
  return _val;
}


SWIGINTERN VALUE
Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER));
  return _val;
}


SWIGINTERN VALUE
Rule80A_SHTEXTRANA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANA));
  return _val;
}


SWIGINTERN VALUE
Rule80A_SHTEXTRANW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANW));
  return _val;
}


SWIGINTERN VALUE
Rule80A_PRGINDEXARBINV_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBINV));
  return _val;
}


SWIGINTERN VALUE
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
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
Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE));
  return _val;
}


SWIGINTERN VALUE
Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE));
  return _val;
}


SWIGINTERN VALUE
Rule80A_ALLOTHERAGN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_ALLOTHERAGN));
  return _val;
}


SWIGINTERN VALUE
Rule80A_PRGNONINDEXARBOTHAGN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBOTHAGN));
  return _val;
}


SWIGINTERN VALUE
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
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
Rule80A_AGENCYSINGLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCYSINGLE));
  return _val;
}


SWIGINTERN VALUE
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
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
Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING));
  return _val;
}


SWIGINTERN VALUE
Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE));
  return _val;
}


SWIGINTERN VALUE
Rule80A_PRGNONINDEXARBMEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBMEM));
  return _val;
}


SWIGINTERN VALUE
Rule80A_PRGNONINDEXARBOTHMEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGNONINDEXARBOTHMEM));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
Rule80A_PRGINDEXARBMEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRGINDEXARBMEM));
  return _val;
}


SWIGINTERN VALUE
Rule80A_INVINESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_INVINESTOR));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_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_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE));
  return _val;
}


SWIGINTERN VALUE
Rule80A_COMPETINGDEALER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETINGDEALER));
  return _val;
}


SWIGINTERN VALUE
Rule80A_COMPDEALER1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPDEALER1));
  return _val;
}


SWIGINTERN VALUE
Rule80A_SHTEXTRANNONMEM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHTEXTRANNONMEM));
  return _val;
}


SWIGINTERN VALUE
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
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
Rule80A_MARKETMAKER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_MARKETMAKER));
  return _val;
}


SWIGINTERN VALUE
Rule80A_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_SPECIALIST));
  return _val;
}


SWIGINTERN VALUE
Rule80A_COMPDEALER2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPDEALER2));
  return _val;
}


SWIGINTERN VALUE
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
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
CorporateAction_MERGER_REORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_MERGER_REORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_SYMBOL_CONVERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SYMBOL_CONVERSION));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NEW));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_SUCCESSION_EVENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SUCCESSION_EVENT));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_STOCK_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STOCK_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
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
CorporateAction_POSITION_CONSOLIDATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_POSITION_CONSOLIDATION));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_SPINOFF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPINOFF));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EXDIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXDIVIDEND));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EX_INTEREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_INTEREST));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_LIQUIDATION_REORGANIZATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LIQUIDATION_REORGANIZATION));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_CASH_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CASH_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
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
CorporateAction_RIGHTS_OFFERING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_RIGHTS_OFFERING));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_SHAREHOLDER_MEETING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SHAREHOLDER_MEETING));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_WARRANT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_WARRANT));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EXDIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXDIST));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EX_RIGHTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_RIGHTS));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EX_DISTRIBUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DISTRIBUTION));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EX_DIVIDEND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DIVIDEND));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_TENDER_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_TENDER_OFFER));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_SPECIAL_ACTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPECIAL_ACTION));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EXINTEREST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXINTEREST));
  return _val;
}


SWIGINTERN VALUE
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
CorporateAction_CUSIP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CUSIP));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_LEAP_ROLLOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LEAP_ROLLOVER));
  return _val;
}


SWIGINTERN VALUE
CorporateAction_EXRIGHTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EXRIGHTS));
  return _val;
}


SWIGINTERN VALUE
TerminationType_TERM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_TERM));
  return _val;
}


SWIGINTERN VALUE
TerminationType_FLEXIBLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_FLEXIBLE));
  return _val;
}


SWIGINTERN VALUE
TerminationType_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_OPEN));
  return _val;
}


SWIGINTERN VALUE
TerminationType_OVERNIGHT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::TerminationType_OVERNIGHT));
  return _val;
}


SWIGINTERN VALUE
PosMaintAction_REPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REPLACE));
  return _val;
}


SWIGINTERN VALUE
PosMaintAction_NEW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_NEW));
  return _val;
}


SWIGINTERN VALUE
PosMaintAction_REVERSE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REVERSE));
  return _val;
}


SWIGINTERN VALUE
PosMaintAction_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_CANCEL));
  return _val;
}


SWIGINTERN VALUE
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
ComplexEventPriceTimeType_EXPIRATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_EXPIRATION));
  return _val;
}


SWIGINTERN VALUE
ComplexEventPriceTimeType_IMMEDIATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_IMMEDIATE));
  return _val;
}


SWIGINTERN VALUE
UnderlyingFXRateCalc_DIVIDE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_DIVIDE));
  return _val;
}


SWIGINTERN VALUE
UnderlyingFXRateCalc_MULTIPLY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_MULTIPLY));
  return _val;
}


SWIGINTERN VALUE
OddLot_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OddLot_NO));
  return _val;
}


SWIGINTERN VALUE
OddLot_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::OddLot_YES));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_ACCOUNTLEVELREJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCOUNTLEVELREJECT));
  return _val;
}


SWIGINTERN VALUE
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
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
AllocStatus_INCOMPLETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_INCOMPLETE));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_ALLOCATION_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ALLOCATION_PENDING));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_BLOCKLEVELREJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_BLOCKLEVELREJECT));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_REJECTEDBYINTERMEDIARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTEDBYINTERMEDIARY));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_REVERSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REVERSED));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_RECEIVED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_RECEIVED));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_PARTIAL_ACCEPT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_PARTIAL_ACCEPT));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
AllocStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
IncTaxInd_NET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_NET));
  return _val;
}


SWIGINTERN VALUE
IncTaxInd_GROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_GROSS));
  return _val;
}


SWIGINTERN VALUE
PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION));
  return _val;
}


SWIGINTERN VALUE
PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES));
  return _val;
}


SWIGINTERN VALUE
PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION));
  return _val;
}


SWIGINTERN VALUE
PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES));
  return _val;
}


SWIGINTERN VALUE
PosReqStatus_COMPLETED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED));
  return _val;
}


SWIGINTERN VALUE
PosReqStatus_REJECTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_REJECTED));
  return _val;
}


SWIGINTERN VALUE
PosReqStatus_COMPLETEDWITHWARNINGS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETEDWITHWARNINGS));
  return _val;
}


SWIGINTERN VALUE
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
PriorityIndicator_PRIORITY_UNCHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_PRIORITY_UNCHANGED));
  return _val;
}


SWIGINTERN VALUE
PriorityIndicator_PRIORITYUNCHANGED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_PRIORITYUNCHANGED));
  return _val;
}


SWIGINTERN VALUE
PriorityIndicator_LOSTPRIORITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_LOSTPRIORITY));
  return _val;
}


SWIGINTERN VALUE
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
MoneyLaunderingStatus_NOTCHECKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_NOTCHECKED));
  return _val;
}


SWIGINTERN VALUE
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
MoneyLaunderingStatus_EXAUTHCREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXAUTHCREDIT));
  return _val;
}


SWIGINTERN VALUE
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
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
MoneyLaunderingStatus_NOT_CHECKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_NOT_CHECKED));
  return _val;
}


SWIGINTERN VALUE
MoneyLaunderingStatus_PASSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_PASSED));
  return _val;
}


SWIGINTERN VALUE
MoneyLaunderingStatus_EXEMPT_1_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_1));
  return _val;
}


SWIGINTERN VALUE
MoneyLaunderingStatus_EXCLIENTMONEYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXCLIENTMONEYTYPE));
  return _val;
}


SWIGINTERN VALUE
MoneyLaunderingStatus_EXEMPT_2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_2));
  return _val;
}


SWIGINTERN VALUE
MoneyLaunderingStatus_EXBELOWLIM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXBELOWLIM));
  return _val;
}


SWIGINTERN VALUE
MoneyLaunderingStatus_EXEMPT_3_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_3));
  return _val;
}


SWIGINTERN VALUE
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
LotType_ROUND_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT));
  return _val;
}


SWIGINTERN VALUE
LotType_ODD_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LotType_ODD_LOT));
  return _val;
}


SWIGINTERN VALUE
LotType_BLOCK_LOT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::LotType_BLOCK_LOT));
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_FLAT_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FLAT_CURVE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_REST_OF_BOOK_VWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_REST_OF_BOOK_VWAP);
  return _val;
}


SWIGINTERN VALUE
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
QuoteCondition_TRADING_RANGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RANGE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_HALT_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_HALT_ETH);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_BID_OFFER_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_BID_OFFER_SPECIALIST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_CONSOLBEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CONSOLBEST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_CROSSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CROSSED);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_NO_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NO_OPEN);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_HALT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_HALT);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_PREOPENING_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_PREOPENING_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_OPEN_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_RESERVED_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_RESERVED_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_OUTRIGHT_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OUTRIGHT_PRICE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_IMPLIED_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_IMPLIED_PRICE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_DEPTH_ON_OFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_OFFER);
  return _val;
}


SWIGINTERN VALUE
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
QuoteCondition_REGULAR_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_REGULAR_ETH);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_ROTATION_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION_ETH);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_NONFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NONFIRM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_EXCHANGE_BEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_EXCHANGE_BEST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_DEPTH_ON_BID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_BID);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_CLOSING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSING);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_VIEW_OF_COMMON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_VIEW_OF_COMMON);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_FORBIDDEN_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FORBIDDEN_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_LOCKED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_LOCKED);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_ORDER_INFLUX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_INFLUX);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_PENDING);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_RESUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_RESUME);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_TRADING_RESUME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RESUME);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_OUT_OF_SEQUENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OUT_OF_SEQUENCE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_END_OF_DAY_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_END_OF_DAY_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_FROZEN_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FROZEN_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_OPENING_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPENING_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_MANUAL_SLOW_QUOTE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_MANUAL_SLOW_QUOTE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_DISSEMINATION);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_DUE_TO_RELATED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_RELATED);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_VOLUME_ALERT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_VOLUME_ALERT);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_FAST_MARKET_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_MARKET_ETH);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_INACTIVE_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_INACTIVE_ETH);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_DISSEMINATION);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_SURVEILLANCE_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_SURVEILLANCE_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_DEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_OPEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_AUTOMATIC_EXECUTION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_DUE_TO_NEWS_PENDING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_PENDING);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_NO_ACTIVE_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NO_ACTIVE_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_OFFER_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OFFER_SPECIALIST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_SUSPENDED_SAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_SUSPENDED_SAM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_RESTRICTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_RESTRICTED);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_NON_FIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_NON_FIRM);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_CLOSED_INACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED_INACTIVE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_ADDITIONAL_INFO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_EQUIPMENT_CHANGEOVER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_EQUIPMENT_CHANGEOVER);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_EXCHBEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_EXCHBEST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_FAST_TRADING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_TRADING);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_FULL_CURVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FULL_CURVE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_MEDIAN_PRICE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_MEDIAN_PRICE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_OPEN_ACTIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_ACTIVE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_ORDER_IMBALANCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_IMBALANCE);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_AUTOMATIC_EXECUTION_ETH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION_ETH);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_ROTATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_BID_SPECIALIST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_BID_SPECIALIST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_FAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_FAST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_CONSOLIDATED_BEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CONSOLIDATED_BEST);
  return _val;
}


SWIGINTERN VALUE
QuoteCondition_CLOSED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED);
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_OWNED_BY_30_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_30));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_PROVIDES_QUOTES_TO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_QUOTES_TO));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_POSTS_TRADES_TO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_POSTS_TRADES_TO));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_REGULATORY_OWNER_OF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_REGULATORY_OWNER_OF));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_SUBSIDIARY_OF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SUBSIDIARY_OF));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_HAS_MEMBERS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_HAS_MEMBERS));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_ENTERS_TRADES_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_ENTERS_TRADES_THROUGH));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_BENEFICIAL_OWNER_OF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_BENEFICIAL_OWNER_OF));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_OWNED_BY_34_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_34));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_CONTROLS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CONTROLS));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_REQUESTS_QUOTES_FROM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_REQUESTS_QUOTES_FROM));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_SPONSORS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SPONSORS));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_CLEARS_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CLEARS_THROUGH));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_OWNED_BY_36_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_OWNED_BY_36));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_BROKERS_TRADES_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_BROKERS_TRADES_THROUGH));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_INVESTS_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_INVESTS_THROUGH));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_PARTICIPANT_OF_MARKETPLACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PARTICIPANT_OF_MARKETPLACE));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_LEGAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_LEGAL));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_ENTERS_TRADES_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_ENTERS_TRADES_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_CARRIES_POSITIONS_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CARRIES_POSITIONS_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_IS_GUARANTEED_BY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_IS_GUARANTEED_BY));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_IS_CONTROLLED_BY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_IS_CONTROLLED_BY));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_TRADING_SERVICES_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_IS_ALSO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_IS_ALSO));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_PARENT_FIRM_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PARENT_FIRM_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_APPROVED_BY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_APPROVED_BY));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_APPROVES_OF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_APPROVES_OF));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_USES_TRADING_SERVICES_OF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_USES_TRADING_SERVICES_OF));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_PROVIDES_GUARANTEE_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_GUARANTEE_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_SPONSORED_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_SPONSORED_THROUGH));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_TRADES_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_TRADES_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_CLEARS_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_CLEARS_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_BROKERS_TRADES_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_BROKERS_TRADES_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_INVESTS_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_INVESTS_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_PROVIDES_MARKETPLACE_FOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_PROVIDES_MARKETPLACE_FOR));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_MEMBER_OF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_MEMBER_OF));
  return _val;
}


SWIGINTERN VALUE
PartyRelationship_TRADES_THROUGH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::PartyRelationship_TRADES_THROUGH));
  return _val;
}


SWIGINTERN VALUE
SettlLocation_EUROCLEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_EUROCLEAR);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_CEDEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_CEDEL);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_PARTICIPANT_TRUST_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_PARTICIPANT_TRUST_COMPANY);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_PHYSICAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_PHYSICAL);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_EURO_CLEAR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_EURO_CLEAR);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_FEDERALBOOKENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_FEDERALBOOKENTRY);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_PARTICIPANTTRUSTCOMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_PARTICIPANTTRUSTCOMPANY);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_DEPOSITORY_TRUST_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_DEPOSITORY_TRUST_COMPANY);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_DEPOSITORYTRUSTCOMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_DEPOSITORYTRUSTCOMPANY);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_LOCAL_MARKET_SETTLE_LOCATION);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_LOCALMARKETSETTLELOCATION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_LOCALMARKETSETTLELOCATION);
  return _val;
}


SWIGINTERN VALUE
SettlLocation_FEDERAL_BOOK_ENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SettlLocation_FEDERAL_BOOK_ENTRY);
  return _val;
}


SWIGINTERN VALUE
DiscretionScope_LOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_LOCAL));
  return _val;
}


SWIGINTERN VALUE
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
DiscretionScope_NATIONALEXCLUDINGLOCAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONALEXCLUDINGLOCAL));
  return _val;
}


SWIGINTERN VALUE
DiscretionScope_GLOBAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_GLOBAL));
  return _val;
}


SWIGINTERN VALUE
DiscretionScope_NATIONAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL));
  return _val;
}


SWIGINTERN VALUE
DiscretionScope_LOCALEXCHANGEECNATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_LOCALEXCHANGEECNATS));
  return _val;
}


SWIGINTERN VALUE
OwnerType_NETWORKINGSUBACCT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_NETWORKINGSUBACCT));
  return _val;
}


SWIGINTERN VALUE
OwnerType_PUBLIC_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PUBLIC_COMPANY));
  return _val;
}


SWIGINTERN VALUE
OwnerType_INDIVIDUAL_TRUSTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_TRUSTEE));
  return _val;
}


SWIGINTERN VALUE
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
OwnerType_INDIVIDUAL_INVESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_INVESTOR));
  return _val;
}


SWIGINTERN VALUE
OwnerType_COMPANY_TRUSTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMPANY_TRUSTEE));
  return _val;
}


SWIGINTERN VALUE
OwnerType_CORPBODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_CORPBODY));
  return _val;
}


SWIGINTERN VALUE
OwnerType_INDIVTRUSTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVTRUSTEE));
  return _val;
}


SWIGINTERN VALUE
OwnerType_PENSIONPLAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PENSIONPLAN));
  return _val;
}


SWIGINTERN VALUE
OwnerType_PRIVATE_COMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PRIVATE_COMPANY));
  return _val;
}


SWIGINTERN VALUE
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
OwnerType_NON_PROFITORG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_NON_PROFITORG));
  return _val;
}


SWIGINTERN VALUE
OwnerType_PRIVATECOMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PRIVATECOMPANY));
  return _val;
}


SWIGINTERN VALUE
OwnerType_PENSION_PLAN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PENSION_PLAN));
  return _val;
}


SWIGINTERN VALUE
OwnerType_COMPANYTRUSTEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMPANYTRUSTEE));
  return _val;
}


SWIGINTERN VALUE
OwnerType_TRUSTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_TRUSTS));
  return _val;
}


SWIGINTERN VALUE
OwnerType_FIDUCIARIES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_FIDUCIARIES));
  return _val;
}


SWIGINTERN VALUE
OwnerType_INDIVINVESTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVINVESTOR));
  return _val;
}


SWIGINTERN VALUE
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
OwnerType_CORPORATE_BODY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_CORPORATE_BODY));
  return _val;
}


SWIGINTERN VALUE
OwnerType_PUBLICCOMPANY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_PUBLICCOMPANY));
  return _val;
}


SWIGINTERN VALUE
OwnerType_CUSTODIANMINORSACT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_CUSTODIANMINORSACT));
  return _val;
}


SWIGINTERN VALUE
OwnerType_NOMINEE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::OwnerType_NOMINEE));
  return _val;
}


SWIGINTERN VALUE
ApplQueueResolution_END_SESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_END_SESSION));
  return _val;
}


SWIGINTERN VALUE
ApplQueueResolution_QUEUEFLUSHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_QUEUEFLUSHED));
  return _val;
}


SWIGINTERN VALUE
ApplQueueResolution_QUEUE_FLUSHED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_QUEUE_FLUSHED));
  return _val;
}


SWIGINTERN VALUE
ApplQueueResolution_ENDSESSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_ENDSESSION));
  return _val;
}


SWIGINTERN VALUE
ApplQueueResolution_OVERLAYLAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_OVERLAYLAST));
  return _val;
}


SWIGINTERN VALUE
ApplQueueResolution_OVERLAY_LAST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_OVERLAY_LAST));
  return _val;
}


SWIGINTERN VALUE
ApplQueueResolution_NOACTIONTAKEN_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_NOACTIONTAKEN));
  return _val;
}


SWIGINTERN VALUE
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
QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT));
  return _val;
}


SWIGINTERN VALUE
QuoteResponseLevel_ACKEACH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKEACH));
  return _val;
}


SWIGINTERN VALUE
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
QuoteResponseLevel_ACKNEG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNEG));
  return _val;
}


SWIGINTERN VALUE
QuoteResponseLevel_NOACK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_NOACK));
  return _val;
}


SWIGINTERN VALUE
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
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
QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_NO_ACKNOWLEDGEMENT));
  return _val;
}


SWIGINTERN VALUE
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
ExecAckStatus_DONT_KNOW_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_DONT_KNOW));
  return _val;
}


SWIGINTERN VALUE
ExecAckStatus_ACCEPTED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_ACCEPTED));
  return _val;
}


SWIGINTERN VALUE
NetGrossInd_NET_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_NET));
  return _val;
}


SWIGINTERN VALUE
NetGrossInd_GROSS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_GROSS));
  return _val;
}


SWIGINTERN VALUE
CxlType_PARTIAL_CANCEL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::CxlType_PARTIAL_CANCEL));
  return _val;
}


SWIGINTERN VALUE
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
DeskTypeSource_NASD_OATS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DeskTypeSource_NASD_OATS));
  return _val;
}


SWIGINTERN VALUE
DiscretionRoundDirection_MOREPASSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MOREPASSIVE));
  return _val;
}


SWIGINTERN VALUE
DiscretionRoundDirection_MOREAGGRESSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MOREAGGRESSIVE));
  return _val;
}


SWIGINTERN VALUE
DiscretionRoundDirection_MORE_AGGRESSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_AGGRESSIVE));
  return _val;
}


SWIGINTERN VALUE
DiscretionRoundDirection_MORE_PASSIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_PASSIVE));
  return _val;
}


SWIGINTERN VALUE
BidDescriptorType_COUNTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_COUNTRY));
  return _val;
}


SWIGINTERN VALUE
BidDescriptorType_INDEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_INDEX));
  return _val;
}


SWIGINTERN VALUE
BidDescriptorType_SECTOR_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_SECTOR));
  return _val;
}


SWIGINTERN VALUE
NetworkStatusResponseType_INCREMENTAL_UPDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_INCREMENTAL_UPDATE));
  return _val;
}


SWIGINTERN VALUE
NetworkStatusResponseType_INCREMENTALUPDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_INCREMENTALUPDATE));
  return _val;
}


SWIGINTERN VALUE
NetworkStatusResponseType_FULL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_FULL));
  return _val;
}


SWIGINTERN VALUE
QuoteType_INDICATIVE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_INDICATIVE));
  return _val;
}


SWIGINTERN VALUE
QuoteType_RESTRICTEDTRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_RESTRICTEDTRADEABLE));
  return _val;
}


SWIGINTERN VALUE
QuoteType_RESTRICTED_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_RESTRICTED_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
QuoteType_TRADEABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_TRADEABLE));
  return _val;
}


SWIGINTERN VALUE
QuoteType_COUNTER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::QuoteType_COUNTER));
  return _val;
}


SWIGINTERN VALUE
DiscretionInst_RELVWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELVWAP));
  return _val;
}


SWIGINTERN VALUE
DiscretionInst_RELLOCPRIMPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELLOCPRIMPX));
  return _val;
}


SWIGINTERN VALUE
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
DiscretionInst_RELMIDPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELMIDPX));
  return _val;
}


SWIGINTERN VALUE
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
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
DiscretionInst_RELDISPPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELDISPPX));
  return _val;
}


SWIGINTERN VALUE
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
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
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
DiscretionInst_RELMKTPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELMKTPX));
  return _val;
}


SWIGINTERN VALUE
DiscretionInst_RELPRIMPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELPRIMPX));
  return _val;
}


SWIGINTERN VALUE
DiscretionInst_RELLSTPX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELLSTPX));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
CrossPrioritization_BUY_SIDE_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUY_SIDE_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
CrossPrioritization_SELL_SIDE_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELL_SIDE_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
CrossPrioritization_NONE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_NONE));
  return _val;
}


SWIGINTERN VALUE
CrossPrioritization_SELLSIDE_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELLSIDE_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
CrossPrioritization_BUYSIDE_PRIORITIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUYSIDE_PRIORITIZED));
  return _val;
}


SWIGINTERN VALUE
IOIOthSvc_AUTEX_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_AUTEX));
  return _val;
}


SWIGINTERN VALUE
IOIOthSvc_BRIDGE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_BRIDGE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPSUB_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPSUB));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDENTRYTYPE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_INSUFFICIENT_CREDIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_CREDIT));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPMKTDEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPMKTDEPTH));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPENTRY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPENTRY));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_INSUFFICIENT_BANDWIDTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_BANDWIDTH));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_SCOPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SCOPE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPMDIMPLICITDELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPMDIMPLICITDELETE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNKNOWNSYM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNKNOWNSYM));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPMDUPDATE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPMDUPDATE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_DUPLICATE_MDREQID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_DUPLICATE_MDREQID));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_DUPID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_DUPID));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDUPDATETYPE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNKNOWN_SYMBOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNKNOWN_SYMBOL));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_INSBAND_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSBAND));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPSCOPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPSCOPE));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MARKETDEPTH));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPAGGBK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPAGGBK));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_INSUFFICIENT_PERMISSIONS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_PERMISSIONS));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_INSPERM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSPERM));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPTRDSESSIONID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPTRDSESSIONID));
  return _val;
}


SWIGINTERN VALUE
MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
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
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
ApplReqType_CANCEL_RETRANSMISSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION));
  return _val;
}


SWIGINTERN VALUE
AggressorIndicator_NO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_NO));
  return _val;
}


SWIGINTERN VALUE
AggressorIndicator_YES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_YES));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_APPNA_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_APPNA));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNKNOWN_SECURITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_SECURITY));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNKNMSGTYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNMSGTYPE));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_CONDFLDMISS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_CONDFLDMISS));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNKNID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNID));
  return _val;
}


SWIGINTERN VALUE
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
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
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
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
BusinessRejectReason_UNKNOWN_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_ID));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_NOTAUTH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NOTAUTH));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_NODELIVTOFIRM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NODELIVTOFIRM));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_OTHER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_OTHER));
  return _val;
}


SWIGINTERN VALUE
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
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
BusinessRejectReason_NOT_AUTHORIZED_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NOT_AUTHORIZED));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNKNSEC_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNSEC));
  return _val;
}


SWIGINTERN VALUE
BusinessRejectReason_UNKOWN_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKOWN_ID));
  return _val;
}


SWIGINTERN VALUE
BookingType_REGULAR_BOOKING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_REGULAR_BOOKING));
  return _val;
}


SWIGINTERN VALUE
BookingType_REGULARBOOKING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_REGULARBOOKING));
  return _val;
}


SWIGINTERN VALUE
BookingType_CFD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_CFD));
  return _val;
}


SWIGINTERN VALUE
BookingType_CFDCONTRACTFORDIFFERENCE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_CFDCONTRACTFORDIFFERENCE));
  return _val;
}


SWIGINTERN VALUE
BookingType_TOTALRETURNSWAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(FIX::BookingType_TOTALRETURNSWAP));
  return _val;
}


SWIGINTERN VALUE
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 cSessionID;

SWIGINTERN VALUE
_wrap_new_SessionID__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionID";
  
  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 ;
  FIX::SessionID *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SessionID";
  
  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), "in method '" "FIX::SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::SessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::SessionID" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionID" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::SessionID *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SessionID";
  
  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), "in method '" "FIX::SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::SessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SessionID'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID_getBeginString(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  FIX::BeginString *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getBeginString" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    FIX::BeginString const &_result_ref = ((FIX::SessionID const *)arg1)->getBeginString();
    result = (FIX::BeginString *) &_result_ref;
  }
  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 ;
  FIX::SenderCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSenderCompID" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    FIX::SenderCompID const &_result_ref = ((FIX::SessionID const *)arg1)->getSenderCompID();
    result = (FIX::SenderCompID *) &_result_ref;
  }
  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 ;
  FIX::TargetCompID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getTargetCompID" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    FIX::TargetCompID const &_result_ref = ((FIX::SessionID const *)arg1)->getTargetCompID();
    result = (FIX::TargetCompID *) &_result_ref;
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSessionQualifier" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    std::string const &_result_ref = ((FIX::SessionID const *)arg1)->getSessionQualifier();
    result = (std::string *) &_result_ref;
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isFIXT" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "toString" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "toStringFrozen" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    std::string const &_result_ref = ((FIX::SessionID const *)arg1)->toStringFrozen();
    result = (std::string *) &_result_ref;
  }
  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), "in method '" "fromString" "', argument " "1"" of type '" "FIX::SessionID *""'"); 
  }
  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), "in method '" "fromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  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), "in method '" "toString" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    temp2 = std::string((char*)STR2CSTR(argv[0]));
    arg2 = &temp2;
  }
  {
    std::string &_result_ref = ((FIX::SessionID const *)arg1)->toString(*arg2);
    result = (std::string *) &_result_ref;
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'SessionID_toString'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionID___invert__(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  FIX::SessionID result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "operator ~" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "__str__" "', argument " "1"" of type '" "FIX::SessionID *""'"); 
  }
  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;
}

SWIGINTERN VALUE
_wrap___lt____SWIG_4(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator <" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "FIX::operator <" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded '__lt__'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap___eq____SWIG_4(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::operator ==" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "FIX::operator ==" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator ==" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded '__eq__'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap___lshift____SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  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), "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::SessionID const &)*arg2);
    result = (std::ostream *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___rshift____SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::istream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  std::istream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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), "in method '" "FIX::operator >>" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >>" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  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), "in method '" "FIX::operator >>" "', argument " "2"" of type '" "FIX::SessionID &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >>" "', argument " "2"" of type '" "FIX::SessionID &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    std::istream &_result_ref = FIX::operator >>(*arg1,*arg2);
    result = (std::istream *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class cDictionary;

SWIGINTERN VALUE
_wrap_new_Dictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::Dictionary *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::Dictionary";
  
  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), "in method '" "FIX::Dictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Dictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::Dictionary *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Dictionary";
  
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Dictionary'");
  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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getName" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  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;
}


SWIGINTERN VALUE
_wrap_Dictionary_size(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "size" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  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 ;
  std::string result;
  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), "in method '" "getString" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getString" "', argument " "3"" of type '" "bool""'");
  } 
  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 ;
  std::string result;
  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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getString" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Dictionary_getString'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Dictionary_getLong(int argc, VALUE *argv, VALUE self) {
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  long result;
  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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getLong" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  double result;
  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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getDouble" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getBool" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  int result;
  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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getDay" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "setString" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  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), "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "setString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->setString((std::string const &)*arg2,(std::string 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( 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), "in method '" "setLong" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  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), "in method '" "setLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setLong" "', argument " "3"" of type '" "long""'");
  } 
  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), "in method '" "setDouble" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  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), "in method '" "setDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setDouble" "', argument " "3"" of type '" "double""'");
  } 
  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), "in method '" "setBool" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  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), "in method '" "setBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setBool" "', argument " "3"" of type '" "bool""'");
  } 
  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), "in method '" "setDay" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  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), "in method '" "setDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "setDay" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  bool result;
  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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "has" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "has" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "has" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "merge" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  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), "in method '" "merge" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "merge" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  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 ;
  FIX::Dictionary::iterator result;
  void *argp1 = 0 ;
  int res1 = 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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "begin" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  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 ;
  FIX::Dictionary::iterator result;
  void *argp1 = 0 ;
  int res1 = 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__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "end" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  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
BEGINSTRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::BEGINSTRING);
  return _val;
}


SWIGINTERN VALUE
SENDERCOMPID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SENDERCOMPID);
  return _val;
}


SWIGINTERN VALUE
TARGETCOMPID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TARGETCOMPID);
  return _val;
}


SWIGINTERN VALUE
SESSION_QUALIFIER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SESSION_QUALIFIER);
  return _val;
}


SWIGINTERN VALUE
DEFAULT_APPLVERID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DEFAULT_APPLVERID);
  return _val;
}


SWIGINTERN VALUE
CONNECTION_TYPE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CONNECTION_TYPE);
  return _val;
}


SWIGINTERN VALUE
USE_DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::USE_DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
SEND_RESETSEQNUMFLAG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SEND_RESETSEQNUMFLAG);
  return _val;
}


SWIGINTERN VALUE
SEND_REDUNDANT_RESENDREQUESTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SEND_REDUNDANT_RESENDREQUESTS);
  return _val;
}


SWIGINTERN VALUE
DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
TRANSPORT_DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::TRANSPORT_DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
APP_DATA_DICTIONARY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::APP_DATA_DICTIONARY);
  return _val;
}


SWIGINTERN VALUE
USE_LOCAL_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::USE_LOCAL_TIME);
  return _val;
}


SWIGINTERN VALUE
START_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::START_TIME);
  return _val;
}


SWIGINTERN VALUE
END_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::END_TIME);
  return _val;
}


SWIGINTERN VALUE
START_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::START_DAY);
  return _val;
}


SWIGINTERN VALUE
END_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::END_DAY);
  return _val;
}


SWIGINTERN VALUE
LOGON_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGON_TIME);
  return _val;
}


SWIGINTERN VALUE
LOGOUT_TIME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGOUT_TIME);
  return _val;
}


SWIGINTERN VALUE
LOGON_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGON_DAY);
  return _val;
}


SWIGINTERN VALUE
LOGOUT_DAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGOUT_DAY);
  return _val;
}


SWIGINTERN VALUE
CHECK_COMPID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CHECK_COMPID);
  return _val;
}


SWIGINTERN VALUE
CHECK_LATENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::CHECK_LATENCY);
  return _val;
}


SWIGINTERN VALUE
MAX_LATENCY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MAX_LATENCY);
  return _val;
}


SWIGINTERN VALUE
HEARTBTINT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::HEARTBTINT);
  return _val;
}


SWIGINTERN VALUE
SOCKET_ACCEPT_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_ACCEPT_PORT);
  return _val;
}


SWIGINTERN VALUE
SOCKET_REUSE_ADDRESS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_REUSE_ADDRESS);
  return _val;
}


SWIGINTERN VALUE
SOCKET_CONNECT_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_HOST);
  return _val;
}


SWIGINTERN VALUE
SOCKET_CONNECT_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_PORT);
  return _val;
}


SWIGINTERN VALUE
SOCKET_NODELAY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_NODELAY);
  return _val;
}


SWIGINTERN VALUE
SOCKET_SEND_BUFFER_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_SEND_BUFFER_SIZE);
  return _val;
}


SWIGINTERN VALUE
SOCKET_RECEIVE_BUFFER_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SOCKET_RECEIVE_BUFFER_SIZE);
  return _val;
}


SWIGINTERN VALUE
RECONNECT_INTERVAL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RECONNECT_INTERVAL);
  return _val;
}


SWIGINTERN VALUE
VALIDATE_FIELDS_OUT_OF_ORDER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_OUT_OF_ORDER);
  return _val;
}


SWIGINTERN VALUE
VALIDATE_FIELDS_HAVE_VALUES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_HAVE_VALUES);
  return _val;
}


SWIGINTERN VALUE
VALIDATE_USER_DEFINED_FIELDS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::VALIDATE_USER_DEFINED_FIELDS);
  return _val;
}


SWIGINTERN VALUE
LOGON_TIMEOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGON_TIMEOUT);
  return _val;
}


SWIGINTERN VALUE
LOGOUT_TIMEOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::LOGOUT_TIMEOUT);
  return _val;
}


SWIGINTERN VALUE
FILE_STORE_PATH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FILE_STORE_PATH);
  return _val;
}


SWIGINTERN VALUE
MYSQL_STORE_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
MYSQL_STORE_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_DATABASE);
  return _val;
}


SWIGINTERN VALUE
MYSQL_STORE_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_USER);
  return _val;
}


SWIGINTERN VALUE
MYSQL_STORE_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
MYSQL_STORE_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_HOST);
  return _val;
}


SWIGINTERN VALUE
MYSQL_STORE_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_STORE_PORT);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_STORE_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_STORE_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_DATABASE);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_STORE_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USER);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_STORE_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_STORE_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_HOST);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_STORE_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PORT);
  return _val;
}


SWIGINTERN VALUE
ODBC_STORE_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_STORE_USER);
  return _val;
}


SWIGINTERN VALUE
ODBC_STORE_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_STORE_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
ODBC_STORE_CONNECTION_STRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_STORE_CONNECTION_STRING);
  return _val;
}


SWIGINTERN VALUE
FILE_LOG_PATH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FILE_LOG_PATH);
  return _val;
}


SWIGINTERN VALUE
FILE_LOG_BACKUP_PATH_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::FILE_LOG_BACKUP_PATH);
  return _val;
}


SWIGINTERN VALUE
SCREEN_LOG_SHOW_INCOMING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_INCOMING);
  return _val;
}


SWIGINTERN VALUE
SCREEN_LOG_SHOW_OUTGOING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_OUTGOING);
  return _val;
}


SWIGINTERN VALUE
SCREEN_LOG_SHOW_EVENTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_EVENTS);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_DATABASE);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_USER);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_HOST);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_PORT);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_INCOMING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_INCOMING_TABLE);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_OUTGOING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_OUTGOING_TABLE);
  return _val;
}


SWIGINTERN VALUE
MYSQL_LOG_EVENT_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MYSQL_LOG_EVENT_TABLE);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_USECONNECTIONPOOL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USECONNECTIONPOOL);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_DATABASE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_DATABASE);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USER);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_HOST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_HOST);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PORT);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_INCOMING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_INCOMING_TABLE);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_OUTGOING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_OUTGOING_TABLE);
  return _val;
}


SWIGINTERN VALUE
POSTGRESQL_LOG_EVENT_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_EVENT_TABLE);
  return _val;
}


SWIGINTERN VALUE
ODBC_LOG_USER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_USER);
  return _val;
}


SWIGINTERN VALUE
ODBC_LOG_PASSWORD_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_PASSWORD);
  return _val;
}


SWIGINTERN VALUE
ODBC_LOG_CONNECTION_STRING_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_CONNECTION_STRING);
  return _val;
}


SWIGINTERN VALUE
ODBC_LOG_INCOMING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_INCOMING_TABLE);
  return _val;
}


SWIGINTERN VALUE
ODBC_LOG_OUTGOING_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_OUTGOING_TABLE);
  return _val;
}


SWIGINTERN VALUE
ODBC_LOG_EVENT_TABLE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::ODBC_LOG_EVENT_TABLE);
  return _val;
}


SWIGINTERN VALUE
RESET_ON_LOGON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RESET_ON_LOGON);
  return _val;
}


SWIGINTERN VALUE
RESET_ON_LOGOUT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RESET_ON_LOGOUT);
  return _val;
}


SWIGINTERN VALUE
RESET_ON_DISCONNECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::RESET_ON_DISCONNECT);
  return _val;
}


SWIGINTERN VALUE
REFRESH_ON_LOGON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::REFRESH_ON_LOGON);
  return _val;
}


SWIGINTERN VALUE
MILLISECONDS_IN_TIMESTAMP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::MILLISECONDS_IN_TIMESTAMP);
  return _val;
}


SWIGINTERN VALUE
HTTP_ACCEPT_PORT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::HTTP_ACCEPT_PORT);
  return _val;
}


SWIGINTERN VALUE
PERSIST_MESSAGES_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_FromCharPtr(FIX::PERSIST_MESSAGES);
  return _val;
}


swig_class cSessionSettings;

SWIGINTERN VALUE
_wrap_new_SessionSettings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionSettings";
  
  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 ;
  FIX::SessionSettings *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SessionSettings";
  
  if ((argc < 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), "in method '" "FIX::SessionSettings" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionSettings" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  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 ;
  FIX::SessionSettings *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::SessionSettings";
  
  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), "in method '" "FIX::SessionSettings" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SessionSettings" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SessionSettings'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_has(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "has" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  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), "in method '" "has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "get" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  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), "in method '" "get" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  try {
    {
      FIX::Dictionary const &_result_ref = ((FIX::SessionSettings const *)arg1)->get((FIX::SessionID const &)*arg2);
      result = (FIX::Dictionary *) &_result_ref;
    }
  }
  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), "in method '" "set" "', argument " "1"" of type '" "FIX::SessionSettings *""'"); 
  }
  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), "in method '" "set" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "set" "', argument " "3"" of type '" "FIX::Dictionary""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "3"" of type '" "FIX::Dictionary""'");
    } 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 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "get" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    FIX::Dictionary const &_result_ref = ((FIX::SessionSettings const *)arg1)->get();
    result = (FIX::Dictionary *) &_result_ref;
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'SessionSettings_get'");
  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), "in method '" "set" "', argument " "1"" of type '" "FIX::SessionSettings *""'"); 
  }
  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), "in method '" "set" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'SessionSettings_set'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SessionSettings_size(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "size" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  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 ;
  SwigValueWrapper<std::set<FIX::SessionID > > result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSessions" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  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__setTFIX__SessionID_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_FIX_SessionSettings(FIX::SessionSettings *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap___rshift____SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::istream *arg1 = 0 ;
  FIX::SessionSettings *arg2 = 0 ;
  std::istream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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), "in method '" "FIX::operator >>" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >>" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  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), "in method '" "FIX::operator >>" "', argument " "2"" of type '" "FIX::SessionSettings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator >>" "', argument " "2"" of type '" "FIX::SessionSettings &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  try {
    {
      std::istream &_result_ref = FIX::operator >>(*arg1,*arg2);
      result = (std::istream *) &_result_ref;
    }
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded '__rshift__'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap___lshift____SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  FIX::SessionSettings *arg2 = 0 ;
  std::ostream *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  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), "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::operator <<" "', argument " "2"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  {
    std::ostream &_result_ref = FIX::operator <<(*arg1,(FIX::SessionSettings const &)*arg2);
    result = (std::ostream *) &_result_ref;
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded '__lshift__'");
  return Qnil;
}


swig_class cSession;

#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 ;
  FIX::Session *result = 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";
  
  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), "in method '" "FIX::Session" "', argument " "1"" of type '" "Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session" "', argument " "1"" of type '" "Application &""'"); 
  }
  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), "in method '" "FIX::Session" "', argument " "2"" of type '" "MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session" "', argument " "2"" of type '" "MessageStoreFactory &""'"); 
  }
  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), "in method '" "FIX::Session" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "FIX::Session" "', argument " "4"" of type '" "DataDictionaryProvider const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session" "', argument " "4"" of type '" "DataDictionaryProvider const &""'"); 
  }
  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), "in method '" "FIX::Session" "', argument " "5"" of type '" "TimeRange const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session" "', argument " "5"" of type '" "TimeRange const &""'"); 
  }
  arg5 = reinterpret_cast< TimeRange * >(argp5);
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FIX::Session" "', argument " "6"" of type '" "int""'");
  } 
  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), "in method '" "FIX::Session" "', argument " "7"" of type '" "LogFactory *""'"); 
  }
  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), "in method '" "logon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "logout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "logout" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "logout" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "logout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Session_logout'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isEnabled(int argc, VALUE *argv, VALUE self) {
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isEnabled" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "sentLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "sentLogout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "receivedLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isLoggedOn" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "reset" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "refresh" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  FIX::SessionID *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSessionID" "', argument " "1"" of type '" "FIX::Session const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    FIX::SessionID const &_result_ref = ((FIX::Session const *)arg1)->getSessionID();
    result = (FIX::SessionID *) &_result_ref;
  }
  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), "in method '" "setDataDictionaryProvider" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setDataDictionaryProvider" "', argument " "2"" of type '" "DataDictionaryProvider const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setDataDictionaryProvider" "', argument " "2"" of type '" "DataDictionaryProvider const &""'"); 
  }
  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 ;
  DataDictionaryProvider *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getDataDictionaryProvider" "', argument " "1"" of type '" "FIX::Session const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    DataDictionaryProvider const &_result_ref = ((FIX::Session const *)arg1)->getDataDictionaryProvider();
    result = (DataDictionaryProvider *) &_result_ref;
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  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), "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  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), "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::TargetCompID * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FIX::Session::sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  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), "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  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), "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::Session::sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = 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(argv[0], &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Session_sendToTarget'");
  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__setTFIX__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 ;
  bool result;
  void *argp1 ;
  int res1 = 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), "in method '" "FIX::Session::doesSessionExist" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::doesSessionExist" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  FIX::Session *result = 0 ;
  void *argp1 ;
  int res1 = 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), "in method '" "FIX::Session::lookupSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::lookupSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  FIX::Session *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 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), "in method '" "FIX::Session::lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::Session::lookupSession" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  FIX::Session *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  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), "in method '" "FIX::Session::lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Session_lookupSession'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Session_isSessionRegistered(int argc, VALUE *argv, VALUE self) {
  FIX::SessionID *arg1 = 0 ;
  bool result;
  void *argp1 ;
  int res1 = 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), "in method '" "FIX::Session::isSessionRegistered" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::isSessionRegistered" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  FIX::Session *result = 0 ;
  void *argp1 ;
  int res1 = 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), "in method '" "FIX::Session::registerSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::registerSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "FIX::Session::unregisterSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::Session::unregisterSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  DateTime *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isSessionTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_DateTime,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isSessionTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isSessionTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< DateTime * >(argp2);
  result = (bool)(arg1)->isSessionTime((DateTime 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 ;
  DateTime *arg2 = 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isLogonTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_DateTime,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isLogonTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isLogonTime" "', argument " "2"" of type '" "DateTime const &""'"); 
  }
  arg2 = reinterpret_cast< DateTime * >(argp2);
  result = (bool)(arg1)->isLogonTime((DateTime 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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isInitiator" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isAcceptor" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  TimeRange *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getLogonTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    TimeRange const &_result_ref = (arg1)->getLogonTime();
    result = (TimeRange *) &_result_ref;
  }
  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), "in method '" "setLogonTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setLogonTime" "', argument " "2"" of type '" "TimeRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setLogonTime" "', argument " "2"" of type '" "TimeRange const &""'"); 
  }
  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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSenderDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string const &_result_ref = (arg1)->getSenderDefaultApplVerID();
    result = (std::string *) &_result_ref;
  }
  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), "in method '" "setSenderDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setSenderDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setSenderDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  std::string *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getTargetDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    std::string const &_result_ref = (arg1)->getTargetDefaultApplVerID();
    result = (std::string *) &_result_ref;
  }
  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), "in method '" "setTargetDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setTargetDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setTargetDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSendRedundantResendRequests" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setSendRedundantResendRequests" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setSendRedundantResendRequests" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getCheckCompId" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setCheckCompId" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setCheckCompId" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getCheckLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setCheckLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setCheckLatency" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getMaxLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setMaxLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setMaxLatency" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getLogonTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setLogonTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setLogonTimeout" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getLogoutTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setLogoutTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setLogoutTimeout" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getResetOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setResetOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setResetOnLogon" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getResetOnLogout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setResetOnLogout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setResetOnLogout" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getResetOnDisconnect" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setResetOnDisconnect" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setResetOnDisconnect" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getRefreshOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setRefreshOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setRefreshOnLogon" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setMillisecondsInTimeStamp" "', argument " "2"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getPersistMessages" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setPersistMessages" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setPersistMessages" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPersistMessages(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), "in method '" "setResponder" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "setResponder" "', argument " "2"" of type '" "Responder *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "send" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "send" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "send" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "next" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  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), "in method '" "next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "next" "', argument " "4"" of type '" "bool""'");
  } 
  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), "in method '" "next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  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), "in method '" "next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "next" "', argument " "4"" of type '" "bool""'");
  } 
  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), "in method '" "next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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), "in method '" "next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Session_next'");
  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), "in method '" "disconnect" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  long result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getExpectedSenderNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  long result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getExpectedTargetNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getLog" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 ;
  MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getStore" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  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 cLogFactory;

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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  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), "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'LogFactory_create'");
  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), "in method '" "destroy" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  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), "in method '" "destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class cScreenLogFactory;

SWIGINTERN VALUE
_wrap_new_ScreenLogFactory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = 0 ;
  FIX::ScreenLogFactory *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ScreenLogFactory";
  
  if ((argc < 1) || (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), "in method '" "FIX::ScreenLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ScreenLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  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 ;
  FIX::ScreenLogFactory *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ScreenLogFactory";
  
  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), "in method '" "FIX::ScreenLogFactory" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ScreenLogFactory" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FIX::ScreenLogFactory" "', argument " "3"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ScreenLogFactory'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScreenLogFactory_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::ScreenLogFactory *""'"); 
  }
  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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::ScreenLogFactory *""'"); 
  }
  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), "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'ScreenLogFactory_create'");
  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), "in method '" "destroy" "', argument " "1"" of type '" "FIX::ScreenLogFactory *""'"); 
  }
  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), "in method '" "destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  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 cLog;

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), "in method '" "clear" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  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), "in method '" "backup" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onOutgoing" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  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), "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onEvent" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  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), "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 cNullLog;

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), "in method '" "clear" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  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), "in method '" "backup" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onOutgoing" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  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), "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onEvent" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  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), "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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) {
  FIX::NullLog *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NullLog";
  
  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 cScreenLog;

SWIGINTERN VALUE
_wrap_new_ScreenLog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  FIX::ScreenLog *result = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::ScreenLog";
  
  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), "in method '" "FIX::ScreenLog" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ScreenLog" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FIX::ScreenLog" "', argument " "3"" of type '" "bool""'");
  } 
  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 ;
  FIX::ScreenLog *result = 0 ;
  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";
  
  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), "in method '" "FIX::ScreenLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::ScreenLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FIX::ScreenLog" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FIX::ScreenLog" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FIX::ScreenLog" "', argument " "4"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_ScreenLog'");
  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), "in method '" "clear" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  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), "in method '" "backup" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onOutgoing" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  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), "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onEvent" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  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), "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::ScreenLog const *""'"); 
  }
  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), "in method '" "setMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setMillisecondsInTimeStamp" "', argument " "2"" of type '" "bool""'");
  } 
  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 cFileLogFactory;

SWIGINTERN VALUE
_wrap_new_FileLogFactory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = 0 ;
  FIX::FileLogFactory *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileLogFactory";
  
  if ((argc < 1) || (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), "in method '" "FIX::FileLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  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 ;
  FIX::FileLogFactory *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileLogFactory";
  
  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), "in method '" "FIX::FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::FileLogFactory *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileLogFactory";
  
  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), "in method '" "FIX::FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::FileLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FileLogFactory'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileLogFactory_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::FileLogFactory *""'"); 
  }
  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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::FileLogFactory *""'"); 
  }
  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), "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'FileLogFactory_create'");
  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), "in method '" "destroy" "', argument " "1"" of type '" "FIX::FileLogFactory *""'"); 
  }
  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), "in method '" "destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  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 cFileLog;

SWIGINTERN VALUE
_wrap_new_FileLog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  FIX::FileLog *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileLog";
  
  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), "in method '" "FIX::FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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 ;
  FIX::FileLog *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileLog";
  
  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), "in method '" "FIX::FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FIX::FileLog" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLog" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  FIX::FileLog *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileLog";
  
  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), "in method '" "FIX::FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "FIX::FileLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FIX::FileLog" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileLog" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FileLog'");
  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), "in method '" "clear" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  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), "in method '" "backup" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  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), "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onOutgoing" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  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), "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "onEvent" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  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), "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::FileLog const *""'"); 
  }
  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), "in method '" "setMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setMillisecondsInTimeStamp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setMillisecondsInTimeStamp(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class cMessageStoreFactory;

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 ;
  FIX::MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::MessageStoreFactory *""'"); 
  }
  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), "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "destroy" "', argument " "1"" of type '" "FIX::MessageStoreFactory *""'"); 
  }
  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), "in method '" "destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class cMemoryStoreFactory;

SWIGINTERN VALUE
_wrap_MemoryStoreFactory_create(int argc, VALUE *argv, VALUE self) {
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::MemoryStoreFactory *""'"); 
  }
  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), "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "destroy" "', argument " "1"" of type '" "FIX::MemoryStoreFactory *""'"); 
  }
  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), "in method '" "destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  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) {
  FIX::MemoryStoreFactory *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MemoryStoreFactory";
  
  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 cMessageStore;

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 ;
  bool result;
  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__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "get" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorTstd__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  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), "in method '" "setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  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), "in method '" "incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  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 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 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__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCreationTime" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  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), "in method '" "reset" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  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), "in method '" "refresh" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  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 cMemoryStore;

#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) {
  FIX::MemoryStore *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MemoryStore";
  
  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 ;
  bool result;
  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__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "get" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorTstd__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  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), "in method '" "setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  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), "in method '" "incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  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), "in method '" "setCreationTime" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  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), "in method '" "setCreationTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setCreationTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  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 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 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__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCreationTime" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  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), "in method '" "reset" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  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), "in method '" "refresh" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  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 cMessageStoreFactoryExceptionWrapper;

#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 ;
  FIX::MessageStoreFactoryExceptionWrapper *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageStoreFactoryExceptionWrapper";
  
  if ((argc < 1) || (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), "in method '" "FIX::MessageStoreFactoryExceptionWrapper" "', argument " "1"" of type '" "FIX::MessageStoreFactory *""'"); 
  }
  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 ;
  FIX::MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 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__MessageStoreFactoryExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "create" "', argument " "1"" of type '" "FIX::MessageStoreFactoryExceptionWrapper *""'"); 
  }
  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), "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "create" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "3"" of type '" "bool &""'"); 
  }
  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), "in method '" "create" "', argument " "4"" of type '" "FIX::ConfigError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "4"" of type '" "FIX::ConfigError &""'"); 
  }
  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), "in method '" "destroy" "', argument " "1"" of type '" "FIX::MessageStoreFactoryExceptionWrapper *""'"); 
  }
  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), "in method '" "destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  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 cMessageStoreExceptionWrapper;

#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 ;
  FIX::MessageStoreExceptionWrapper *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::MessageStoreExceptionWrapper";
  
  if ((argc < 1) || (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), "in method '" "FIX::MessageStoreExceptionWrapper" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  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), "in method '" "set" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "set" "', argument " "4"" of type '" "bool &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "4"" of type '" "bool &""'"); 
  }
  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), "in method '" "set" "', argument " "5"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "5"" of type '" "FIX::IOException &""'"); 
  }
  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), "in method '" "get" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorTstd__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  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), "in method '" "get" "', argument " "5"" of type '" "bool &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get" "', argument " "5"" of type '" "bool &""'"); 
  }
  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), "in method '" "get" "', argument " "6"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get" "', argument " "6"" of type '" "FIX::IOException &""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  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__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper const *""'"); 
  }
  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), "in method '" "getNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  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), "in method '" "getNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  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__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper const *""'"); 
  }
  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), "in method '" "getNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  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), "in method '" "getNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  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), "in method '" "setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setNextSenderMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setNextSenderMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  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), "in method '" "setNextSenderMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setNextSenderMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  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), "in method '" "setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setNextTargetMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setNextTargetMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  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), "in method '" "setNextTargetMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setNextTargetMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  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), "in method '" "incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  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), "in method '" "incrNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "incrNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  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), "in method '" "incrNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "incrNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  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), "in method '" "incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  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), "in method '" "incrNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "incrNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  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), "in method '" "incrNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "incrNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  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 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  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__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCreationTime" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  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), "in method '" "getCreationTime" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getCreationTime" "', argument " "2"" of type '" "bool &""'"); 
  }
  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), "in method '" "getCreationTime" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getCreationTime" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  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), "in method '" "reset" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  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), "in method '" "reset" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "reset" "', argument " "2"" of type '" "bool &""'"); 
  }
  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), "in method '" "reset" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "reset" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  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), "in method '" "refresh" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  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), "in method '" "refresh" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "refresh" "', argument " "2"" of type '" "bool &""'"); 
  }
  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), "in method '" "refresh" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "refresh" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  (arg1)->refresh(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


swig_class cFileStoreFactory;

SWIGINTERN VALUE
_wrap_new_FileStoreFactory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::SessionSettings *arg1 = 0 ;
  FIX::FileStoreFactory *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileStoreFactory";
  
  if ((argc < 1) || (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), "in method '" "FIX::FileStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  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 ;
  FIX::FileStoreFactory *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::FileStoreFactory";
  
  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), "in method '" "FIX::FileStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_FileStoreFactory'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStoreFactory_create(int argc, VALUE *argv, VALUE self) {
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::MessageStore *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "create" "', argument " "1"" of type '" "FIX::FileStoreFactory *""'"); 
  }
  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), "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "destroy" "', argument " "1"" of type '" "FIX::FileStoreFactory *""'"); 
  }
  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), "in method '" "destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  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 cFileStore;

#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 ;
  FIX::FileStore *result = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::FileStore";
  
  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)), "in method '" "FIX::FileStore" "', argument " "1"" of type '" "std::string""'"); 
    }
    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), "in method '" "FIX::FileStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::FileStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  bool result;
  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__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "get" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorTstd__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get" "', argument " "4"" of type '" "std::vector<std::string > &""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  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 ;
  int result;
  void *argp1 = 0 ;
  int res1 = 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__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  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), "in method '" "setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  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), "in method '" "incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  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 ;
  UtcTimeStamp result;
  void *argp1 = 0 ;
  int res1 = 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__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCreationTime" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  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), "in method '" "reset" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  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), "in method '" "refresh" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  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 cApplication;

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), "in method '" "onCreate" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  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), "in method '" "onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "onLogon" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  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), "in method '" "onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "onLogout" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  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), "in method '" "onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "toAdmin" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  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), "in method '" "toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "toApp" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  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), "in method '" "toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "fromAdmin" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  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), "in method '" "fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "fromApp" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  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), "in method '" "fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  FIX::Application *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::Application";
  
  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), "in method '" "disown_Application" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  {
    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
    if (director) director->swig_disown();
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class cSynchronizedApplication;

#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 ;
  FIX::SynchronizedApplication *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SynchronizedApplication";
  
  if ((argc < 1) || (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), "in method '" "FIX::SynchronizedApplication" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SynchronizedApplication" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  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), "in method '" "onCreate" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "onLogon" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "onLogout" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "toAdmin" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "toApp" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  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), "in method '" "toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "fromAdmin" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "fromApp" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "m_mutex" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "m_mutex" "', argument " "2"" of type '" "Mutex""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m_mutex" "', argument " "2"" of type '" "Mutex""'");
    } 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 ;
  Mutex result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "m_mutex" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 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), "in method '" "app" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    FIX::Application &_result_ref = (arg1)->app();
    result = (FIX::Application *) &_result_ref;
  }
  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), "in method '" "m_app" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  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), "in method '" "m_app" "', argument " "2"" of type '" "FIX::Application &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m_app" "', argument " "2"" of type '" "FIX::Application &""'"); 
  }
  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 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "m_app" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    FIX::Application &_result_ref = (FIX::Application &) ((arg1)->m_app);
    result = (FIX::Application *) &_result_ref;
  }
  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 cNullApplication;

#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) {
  FIX::NullApplication *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::NullApplication";
  
  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 cInitiator;

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), "in method '" "start" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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), "in method '" "block" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 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), "in method '" "poll" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "poll" "', argument " "2"" of type '" "double""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "poll" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Initiator_poll'");
  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), "in method '" "stop" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stop" "', argument " "2"" of type '" "bool""'");
  } 
  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), "in method '" "stop" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Initiator_stop'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_isLoggedOn(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isLoggedOn" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  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__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getSession" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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), "in method '" "getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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), "in method '" "getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  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 ;
  std::set<FIX::SessionID > *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSessions" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    std::set<FIX::SessionID > const &_result_ref = ((FIX::Initiator const *)arg1)->getSessions();
    result = (std::set<FIX::SessionID > *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setTFIX__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 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "getSession" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  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), "in method '" "getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Initiator_getSession'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Initiator_getSessionSettings(int argc, VALUE *argv, VALUE self) {
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "getSessionSettings" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  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), "in method '" "getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "has" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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), "in method '" "has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isStopped" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 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), "in method '" "getApplication" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    FIX::Application &_result_ref = (arg1)->getApplication();
    result = (FIX::Application *) &_result_ref;
  }
  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 ;
  FIX::MessageStoreFactory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getMessageStoreFactory" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    FIX::MessageStoreFactory &_result_ref = (arg1)->getMessageStoreFactory();
    result = (FIX::MessageStoreFactory *) &_result_ref;
  }
  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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getLog" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  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 cSocketInitiatorBase;

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 ;
  FIX::SocketInitiator *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketInitiatorBase";
  
  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), "in method '" "FIX::SocketInitiator" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketInitiator" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  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), "in method '" "FIX::SocketInitiator" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketInitiator" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  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), "in method '" "FIX::SocketInitiator" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketInitiator" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  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 ;
  FIX::SocketInitiator *result = 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";
  
  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), "in method '" "FIX::SocketInitiator" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketInitiator" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  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), "in method '" "FIX::SocketInitiator" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketInitiator" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  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), "in method '" "FIX::SocketInitiator" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketInitiator" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  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), "in method '" "FIX::SocketInitiator" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketInitiator" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SocketInitiatorBase'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketInitiator(FIX::SocketInitiator *arg1) {
    delete arg1;
}

swig_class cAcceptor;

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 ;
  FIX::Log *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getLog" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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), "in method '" "start" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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), "in method '" "block" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 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), "in method '" "poll" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "poll" "', argument " "2"" of type '" "double""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "poll" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Acceptor_poll'");
  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), "in method '" "stop" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stop" "', argument " "2"" of type '" "bool""'");
  } 
  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), "in method '" "stop" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Acceptor_stop'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_isLoggedOn(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isLoggedOn" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  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__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getSession" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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), "in method '" "getSession" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSession" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Responder,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  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 ;
  std::set<FIX::SessionID > *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getSessions" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    std::set<FIX::SessionID > const &_result_ref = ((FIX::Acceptor const *)arg1)->getSessions();
    result = (std::set<FIX::SessionID > *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setTFIX__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 ;
  FIX::Session *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "getSession" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  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), "in method '" "getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'Acceptor_getSession'");
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Acceptor_getSessionSettings(int argc, VALUE *argv, VALUE self) {
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::Dictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "getSessionSettings" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  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), "in method '" "getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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), "in method '" "has" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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), "in method '" "has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "isStopped" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  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 ;
  FIX::Application *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 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), "in method '" "getApplication" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    FIX::Application &_result_ref = (arg1)->getApplication();
    result = (FIX::Application *) &_result_ref;
  }
  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 ;
  FIX::MessageStoreFactory *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getMessageStoreFactory" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    FIX::MessageStoreFactory &_result_ref = (arg1)->getMessageStoreFactory();
    result = (FIX::MessageStoreFactory *) &_result_ref;
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class cSocketAcceptorBase;

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 ;
  FIX::SocketAcceptor *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SocketAcceptorBase";
  
  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), "in method '" "FIX::SocketAcceptor" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketAcceptor" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  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), "in method '" "FIX::SocketAcceptor" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketAcceptor" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  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), "in method '" "FIX::SocketAcceptor" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketAcceptor" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  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 ;
  FIX::SocketAcceptor *result = 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";
  
  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), "in method '" "FIX::SocketAcceptor" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketAcceptor" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  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), "in method '" "FIX::SocketAcceptor" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketAcceptor" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  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), "in method '" "FIX::SocketAcceptor" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketAcceptor" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  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), "in method '" "FIX::SocketAcceptor" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::SocketAcceptor" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_SocketAcceptorBase'");
  return Qnil;
}


SWIGINTERN void
free_FIX_SocketAcceptor(FIX::SocketAcceptor *arg1) {
    delete arg1;
}

swig_class cDataDictionary;

SWIGINTERN VALUE
_wrap_new_DataDictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FIX::DataDictionary *result = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  
  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 ;
  FIX::DataDictionary *result = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  
  if ((argc < 1) || (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), "in method '" "FIX::DataDictionary" "', argument " "1"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DataDictionary" "', argument " "1"" of type '" "FIX::DataDictionary const &""'"); 
  }
  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 ;
  FIX::DataDictionary *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  
  if ((argc < 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), "in method '" "FIX::DataDictionary" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DataDictionary" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  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 ;
  FIX::DataDictionary *result = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Quickfix::DataDictionary";
  
  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), "in method '" "FIX::DataDictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DataDictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'new_DataDictionary'");
  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), "in method '" "readFromURL" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "readFromURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "readFromURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "readFromDocument" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "readFromDocument" "', argument " "2"" of type '" "DOMDocumentPtr""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "readFromDocument" "', argument " "2"" of type '" "DOMDocumentPtr""'");
    } 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), "in method '" "readFromStream" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "readFromStream" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "readFromStream" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  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 ;
  int *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getOrderedFields" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  result = (int *)((FIX::DataDictionary const *)arg1)->getOrderedFields();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 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), "in method '" "setVersion" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "setVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  std::string result;
  void *argp1 = 0 ;
  int res1 = 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), "in method '" "getVersion" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  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), "in method '" "addField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addFieldName" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addFieldName" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addFieldName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addFieldName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string temp3 ;
  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), "in method '" "getFieldName" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getFieldName" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp3 ;
  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), "in method '" "getFieldTag" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "getFieldTag" "', argument " "2"" of type '" "std::string""'"); 
    }
    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), "in method '" "addValueName" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addValueName" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "addValueName" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addValueName" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  (arg1)->addValueName(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  {
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  std::string temp4 ;
  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), "in method '" "getValueName" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getValueName" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "getValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addMsgType" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "addMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  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), "in method '" "isMsgType" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "addMsgField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "addMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "addMsgField" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  bool result;
  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), "in method '" "isMsgField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "isMsgField" "', argument " "3"" of type '" "int""'");
  } 
  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), "in method '" "addHeaderField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addHeaderField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "addHeaderField" "', argument " "3"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isHeaderField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isHeaderField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addTrailerField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addTrailerField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "addTrailerField" "', argument " "3"" of type '" "bool""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isTrailerField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isTrailerField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addFieldType" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addFieldType" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type""'");
    } 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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  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__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getFieldType" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "getFieldType" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "getFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type &""'"); 
  }
  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), "in method '" "addRequiredField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "addRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "addRequiredField" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  bool result;
  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), "in method '" "isRequiredField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "isRequiredField" "', argument " "3"" of type '" "int""'");
  } 
  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), "in method '" "addFieldValue" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "addFieldValue" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "addFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hasFieldValue" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hasFieldValue" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  bool result;
  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), "in method '" "isFieldValue" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isFieldValue" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "isFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    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), "in method '" "addGroup" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  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), "in method '" "addGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "addGroup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "addGroup" "', argument " "4"" of type '" "int""'");
  } 
  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), "in method '" "addGroup" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "addGroup" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  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 ;
  bool result;
  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), "in method '" "isGroup" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "isGroup" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int temp4 ;
  FIX::DataDictionary *temp5 ;
  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), "in method '" "getGroup" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getGroup" "', argument " "3"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isDataField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isDataField" "', argument " "2"" of type '" "int""'");
  } 
  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 ;
  bool result;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isMultipleValueField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isMultipleValueField" "', argument " "2"" of type '" "int""'");
  } 
  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), "in method '" "checkFieldsOutOfOrder" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "checkFieldsOutOfOrder" "', argument " "2"" of type '" "bool""'");
  } 
  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), "in method '" "checkFieldsHaveValues" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "checkFieldsHaveValues" "', argument " "2"" of type '" "bool""'");
  } 
  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), "in method '" "checkUserDefinedFields" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "checkUserDefinedFields" "', argument " "2"" of type '" "bool""'");
  } 
  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), "in method '" "FIX::DataDictionary::validate" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FIX::DataDictionary::validate" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "FIX::DataDictionary::validate" "', argument " "2"" of type '" "FIX::DataDictionary const *const""'"); 
  }
  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), "in method '" "FIX::DataDictionary::validate" "', argument " "3"" of type '" "FIX::DataDictionary const *const""'"); 
  }
  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), "in method '" "validate" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  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), "in method '" "validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  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), "in method '" "validate" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  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), "in method '" "validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "validate" "', argument " "3"" of type '" "bool""'");
  } 
  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:
  rb_raise(rb_eArgError, "No matching function for overloaded 'DataDictionary_validate'");
  return Qnil;
}



/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_FIX__CheckSumTo_p_FIX__CheckSumField(void *x) {
    return (void *)((FIX::CheckSumField *)  ((FIX::CheckSum *) x));
}
static void *_p_FIX__NullLogTo_p_FIX__Log(void *x) {
    return (void *)((FIX::Log *)  ((FIX::NullLog *) x));
}
static void *_p_FIX__FileLogTo_p_FIX__Log(void *x) {
    return (void *)((FIX::Log *)  ((FIX::FileLog *) x));
}
static void *_p_FIX__ScreenLogTo_p_FIX__Log(void *x) {
    return (void *)((FIX::Log *)  ((FIX::ScreenLog *) x));
}
static void *_p_IntArrayTo_p_int(void *x) {
    return (void *)((int *)  ((IntArray *) x));
}
static void *_p_FIX__SocketInitiatorTo_p_FIX__Initiator(void *x) {
    return (void *)((FIX::Initiator *)  ((FIX::SocketInitiator *) x));
}
static void *_p_FIX__SocketAcceptorTo_p_FIX__Acceptor(void *x) {
    return (void *)((FIX::Acceptor *)  ((FIX::SocketAcceptor *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MDEntryType *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RegistStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrdStatus *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MatchStatus *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BidTradeType *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TradeType *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OpenClose *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Urgency *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::EmailType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AllocTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RegistTransType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOITransType *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecType *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TimeInForce *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OwnershipType *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BookingUnit *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerAction *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ProcessCode *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LotType *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegSide *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TickDirection *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MsgDirection *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::BasisPxType *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::VenueType *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::HandlInst *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCategory *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CxlType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__RelatedContextPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RelatedContextPartyIDSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__RelatedPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RelatedPartyIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__PartyAltIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PartyAltIDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__ContextPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ContextPartyIDSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CommType *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__RelatedPartyAltIDSourceTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::RelatedPartyAltIDSource *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Benchmark *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlType *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DeleteReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DKReason *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CancellationRights *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::CashMargin *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Rule80A *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::AdvSide *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SideTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::Side *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::OrdType *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__CharField(void *x) {
    return (void *)((FIX::CharField *)  ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__GroupTo_p_FIX__FieldMap(void *x) {
    return (void *)((FIX::FieldMap *)  ((FIX::Group *) x));
}
static void *_p_FIX__MessageTo_p_FIX__FieldMap(void *x) {
    return (void *)((FIX::FieldMap *)  ((FIX::Message *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCFICode *) x));
}
static void *_p_FIX__RiskCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskCFICode *) x));
}
static void *_p_FIX__RelationshipRiskCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskCFICode *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartCash *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityType *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__RiskSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuantityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QtyType *) x));
}
static void *_p_FIX__AccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Account *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocAccount *) x));
}
static void *_p_FIX__RelationshipRiskSecurityTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityType *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__RiskSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__RelationshipRiskSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DeleteReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DKReason *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserRequestID *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginExcess *) x));
}
static void *_p_FIX__PartyDetailsListRequestIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyDetailsListRequestID *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidPx *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastQty *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastQty *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskID *) x));
}
static void *_p_FIX__CheckSumFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::CheckSumField *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Username *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeValue *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedText *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MarketDepth *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRptID *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegNumber *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosType *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContAmtType *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosAmtType *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ReportedPx *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastFragment *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__RiskLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskLimitType *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegLimitType *) x));
}
static void *_p_FIX__RelationshipRiskLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStipulations *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ShortQty *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SellerDays *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TierCode *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TransferReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Benchmark *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocText *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StopPx *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossType *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelay *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCategory *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsCategory *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardNumber *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPositions *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDates *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardStartDate *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartDate *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RefreshQty *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigTime *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteType *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumBidders *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__RiskSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSymbolSfx *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__RelationshipRiskSymbolSfxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSymbolSfx *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RptSeq *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OwnerType *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TickRuleType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Currency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CommCurrency *) x));
}
static void *_p_FIX__RiskLimitCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskLimitCurrency *) x));
}
static void *_p_FIX__RelationshipRiskLimitCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskLimitCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidTradeType *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeType *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__RelationshipRiskSeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSeniority *) x));
}
static void *_p_FIX__RiskSeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSeniority *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Seniority *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinQty *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Scope *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvRefID *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BookingUnit *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDReportID *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__PartyDetailsListReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyDetailsListReportID *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CancellationRights *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXML *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RawData *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HandlInst *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdType *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegFactor *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchType *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentSettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskInstrumentSettlType *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlType *) x));
}
static void *_p_FIX__RiskInstrumentSettlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskInstrumentSettlType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmType *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollApplType *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CashMargin *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__RiskWarningLevelPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskWarningLevelPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderPercent *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CrossPercent *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelPercentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskWarningLevelPercent *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EventTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__ContextPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContextPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__RequestedPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RequestedPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__RelatedPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedPartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyRole *) x));
}
static void *_p_FIX__RelatedContextPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedContextPartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CreditRating *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CxlQty *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DividendYield *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegModel *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastPx *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FloorPrice *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PutOrCall *) x));
}
static void *_p_FIX__RiskPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskPutOrCall *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__RelationshipRiskPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskPutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegs *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlType *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CPRegType *) x));
}
static void *_p_FIX__FactorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Factor *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExpiration *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OwnershipType *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionScope *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDestination *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Designation *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Urgency *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowPx *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRef *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSize *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RFQReqID *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideQty *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::XmlData *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumTickets *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRpts *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeCondition *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidYield *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidYield *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderID *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefOrderID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReferencePage *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InputSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityAltIDSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__ContextPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ContextPartyIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__RiskSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityAltIDSource *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityIDSource *) x));
}
static void *_p_FIX__RelatedContextPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RelatedContextPartyIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RiskSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__PartyAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PartyAltIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__RelatedPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RelatedPartyIDSource *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__RelatedPartyAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RelatedPartyAltIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FairValue *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRespID *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationValue *) x));
}
static void *_p_FIX__CharFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::CharField *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMode *) x));
}
static void *_p_FIX__CountryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Country *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Rule80A *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LongQty *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegSwapType *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillQty *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocReportType *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportType *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Password *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewPassword *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReportType *) x));
}
static void *_p_FIX__PartyRelationshipTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyRelationship *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EventType *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RespondentType *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceDelta *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue2 *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__RiskSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbol *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__RelationshipRiskSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSymbol *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::VenueType *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TimeInForce *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AdvSide *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__PartyAltSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyAltSubID *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartyAltSubID *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Signature *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SendingDate *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistID *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientBidID *) x));
}
static void *_p_FIX__RiskInstrumentOperatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskInstrumentOperator *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentOperatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskInstrumentOperator *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatsType *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__EncodedSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSymbol *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Symbol *) x));
}
static void *_p_FIX__NoPartyRelationshipsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyRelationships *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSides *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportToExch *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Subject *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidPx *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Adjustment *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetSubID *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferPx *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPool *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OpenInterest *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideValueInd *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskMaturityMonthYear *) x));
}
static void *_p_FIX__RiskMaturityMonthYearTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskMaturityMonthYear *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDOriginType *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RoutingID *) x));
}
static void *_p_FIX__NoPartyListTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyList *) x));
}
static void *_p_FIX__TotNoPartyListTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoPartyList *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__PartyAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyAltID *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__RelatedPartyAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartyAltID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoRiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskSecurityAltID *) x));
}
static void *_p_FIX__RiskSecurityAltIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityAltID *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SendingTime *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListExecInst *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LinesOfText *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIid *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DueToRelated *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DlvyInst *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecureData *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDMkt *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExpireDate *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BookingRefID *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TickIncrement *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecType *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingDtls *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ModelType *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventText *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransactTime *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsRefID *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDEntryType *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgParPx *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAllocs *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDtls *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingInst *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPrice *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRefID *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRateSources *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocPrice *) x));
}
static void *_p_FIX__StringFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::StringField *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegScope *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecRefID *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LotType *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::EmailType *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OptAttribute *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlLocation *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__AsgnReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AsgnReqID *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExpireTime *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__RelationshipRiskRestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskRestructuringType *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RestructuringType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RoutingType *) x));
}
static void *_p_FIX__RiskRestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskRestructuringType *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BookingType *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatusValue *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListID *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BasisPxType *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskType *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RndPx *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__NoRiskWarningLevelsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskWarningLevels *) x));
}
static void *_p_FIX__NoRelationshipRiskWarningLevelsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskWarningLevels *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HopCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderCompID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCompID *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListStatusType *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__DerivativeSecurityListRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeSecurityListRequestType *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ProductComplex *) x));
}
static void *_p_FIX__RelationshipRiskProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskProductComplex *) x));
}
static void *_p_FIX__RiskProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__TextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Text *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PoolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Pool *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistEmail *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ComplianceID *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartySubID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedContextPartySubID *) x));
}
static void *_p_FIX__RelatedPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__ContextPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContextPartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvId *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListID *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefTagID *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDStreamID *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RptSys *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegQty *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktBidPx *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideExecID *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegMoveType *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientID *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SignatureLength *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinLotSize *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDSecSize *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDay *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIShares *) x));
}
static void *_p_FIX__NoPartyListResponseTypesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyListResponseTypes *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocShares *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__ContextPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContextPartyID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__RelatedPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedPartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__RelatedContextPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatedContextPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CcyAmt *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoHops *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIID *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FillExecID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Spread *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__RiskFlexibleIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RiskFlexibleIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__RelationshipRiskFlexibleIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RelationshipRiskFlexibleIndicator *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementID *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraBroker *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecBroker *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDate *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__Price2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price2 *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__YieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Yield *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlPrice *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssuer *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqType *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReqType *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastShares *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Shares *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__RiskSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__RelationshipRiskSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldType *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNo *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmID *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedPartyAltSubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__PartyAltSubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyAltSubIDType *) x));
}
static void *_p_FIX__RelatedPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedPartySubIDType *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__ContextPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContextPartySubIDType *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelatedContextPartySubIDType *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserStatusText *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Headline *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DatedDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__RiskCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskCouponRate *) x));
}
static void *_p_FIX__RelationshipRiskCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskCouponRate *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplID *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplID *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRefID *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CapPrice *) x));
}
static void *_p_FIX__IntFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::IntField *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundLot *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RejectText *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HopRefID *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikes *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Issuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillPx *) x));
}
static void *_p_FIX__CheckSumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CheckSumField *) ((FIX::CheckSum *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferYield *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::URLLink *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContingencyType *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PosAmt *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastParPx *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BeginString *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNum *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MsgType *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefMsgType *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoFills *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIQty *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradeVolume *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BuyVolume *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__NoPartyAltIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyAltIDs *) x));
}
static void *_p_FIX__NoRelatedPartyAltIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartyAltIDs *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::StrikeTime *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskInstrumentMultiplier *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__RiskInstrumentMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskInstrumentMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ForexReq *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessID *) x));
}
static void *_p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeStampField *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::OddLot *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LanguageCode *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsRefType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__BoolFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::BoolField *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraTrader *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrades *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Volatility *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastMkt *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__PartyListResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyListResponseType *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefAllocID *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SellVolume *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__RelationshipRiskSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__RiskSecurityDescTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityDesc *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardExpDate *) x));
}
static void *_p_FIX__EncodedSymbolLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSymbolLen *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSide *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidID *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCapacities *) x));
}
static void *_p_FIX__NoRiskLimitsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskLimits *) x));
}
static void *_p_FIX__NoRelationshipRiskLimitsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskLimits *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuantityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDate *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MsgDirection *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TickDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::WaveNo *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighPx *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossResend *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgPx *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSourceType *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__RelationshipRiskSecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityGroup *) x));
}
static void *_p_FIX__RiskSecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityGroup *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrders *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegDifference *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CorporateAction *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsID *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CPProgram *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOITransType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocTransType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvTransType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecTransType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosTransType *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OpenClose *) x));
}
static void *_p_FIX__RiskWarningLevelNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskWarningLevelName *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskWarningLevelName *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PositionEffect *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoRelatedContextPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedContextPartySubIDs *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoContextPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContextPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoRelatedPartySubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartySubIDs *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatdSym *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplExtID *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDetls *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__NoRequestedPartyRolesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRequestedPartyRoles *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderSubID *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationType *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TerminationType *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdID *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidType *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketID *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayCumQty *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegPriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__PartyDetailsRequestResultTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyDetailsRequestResult *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndCash *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerAction *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__RiskSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskSecurityID *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MatchStatus *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserStatus *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistStatus *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionStatus *) x));
}
static void *_p_FIX__SecDefStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecDefStatus *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdStatus *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__RiskMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskMaturityTime *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__RelationshipRiskMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTickRules *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PositionLimit *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__NoRelatedPartyAltSubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartyAltSubIDs *) x));
}
static void *_p_FIX__NoPartyAltSubIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyAltSubIDs *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__RiskLimitPlatformTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RiskLimitPlatform *) x));
}
static void *_p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelationshipRiskLimitPlatform *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContAmts *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocType *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SharedCommission *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Commission *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidPx *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIRefID *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__RelationshipRiskProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RelationshipRiskProduct *) x));
}
static void *_p_FIX__RiskProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RiskProduct *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegProduct *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Product *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LocateReqd *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Concession *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CommType *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CumQty *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDFeedType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollReqID *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReqID *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeDate *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListName *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeOnlyField *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDReqID *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RatioQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__RelationshipRiskLimitAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RelationshipRiskLimitAmount *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__RiskLimitAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskLimitAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxShow *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecs *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HostCrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CrossID *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoContextPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContextPartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoRelatedPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__NoRelatedContextPartyIDsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedContextPartyIDs *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FirstPx *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LeavesQty *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndDate *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReqID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TestReqID *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ProcessCode *) x));
}
static void *_p_FIX__UtcDateFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcDateField *) x));
}
static void *_p_FIX__DoubleFieldTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *)  ((FIX::DoubleField *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelationshipRiskInstruments *) x));
}
static void *_p_FIX__NoRiskInstrumentsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRiskInstruments *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExpQty *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSize *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpType *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlMethod *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListMethod *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__SideTo_p_FIX__FieldBase(void *x) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Side *) x));
}
static void *_p_FIX__MemoryStoreTo_p_FIX__MessageStore(void *x) {
    return (void *)((FIX::MessageStore *)  ((FIX::MemoryStore *) x));
}
static void *_p_FIX__FileStoreTo_p_FIX__MessageStore(void *x) {
    return (void *)((FIX::MessageStore *)  ((FIX::FileStore *) x));
}
static void *_p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory(void *x) {
    return (void *)((FIX::LogFactory *)  ((FIX::ScreenLogFactory *) x));
}
static void *_p_FIX__FileLogFactoryTo_p_FIX__LogFactory(void *x) {
    return (void *)((FIX::LogFactory *)  ((FIX::FileLogFactory *) x));
}
static void *_p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory(void *x) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::MemoryStoreFactory *) x));
}
static void *_p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory(void *x) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::FileStoreFactory *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RFQReqID *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeCondition *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedText *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UserRequestID *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__PartyDetailsListRequestIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyDetailsListRequestID *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClientBidID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ReferencePage *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UserStatusText *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDFeedType *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeskType *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TransferReason *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__RelationshipRiskSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskEncodedSecurityDesc *) x));
}
static void *_p_FIX__RiskSecurityDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityDesc *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Username *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__TextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Text *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplID *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplID *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SendingDate *) x));
}
static void *_p_FIX__RiskLimitPlatformTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskLimitPlatform *) x));
}
static void *_p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskLimitPlatform *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__RelatedContextPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedContextPartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__RelatedPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__ContextPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContextPartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessID *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FillExecID *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideExecID *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__PoolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Pool *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationType *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MailingDtls *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__RelatedPartyAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartyAltID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__PartyAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__RiskSecurityAltIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityAltID *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocText *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClientID *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetSubID *) x));
}
static void *_p_FIX__PartyAltSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyAltSubID *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatdSym *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartyAltSubID *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__CountryTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Country *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CommCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Currency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__RiskLimitCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskLimitCurrency *) x));
}
static void *_p_FIX__RelationshipRiskLimitCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskLimitCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDReqID *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Signature *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeDate *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DatedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::HostCrossID *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MailingInst *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrderID *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContraTrader *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRef *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__AsgnReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AsgnReqID *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecRefID *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardExpDate *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExDate *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardNumber *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LastMkt *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeID *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CreditRating *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIID *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SenderSubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AdvId *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__RiskSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityID *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SenderCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::HopCompID *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmID *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EndDate *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::YieldType *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__EncodedSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSymbol *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Symbol *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSymbol *) x));
}
static void *_p_FIX__RiskSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSymbol *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbol *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__RelationshipRiskSymbolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSymbol *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BeginString *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::WaveNo *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDtls *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NewPassword *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Password *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIQty *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefMsgType *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MsgType *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReqID *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollReqID *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXML *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BidID *) x));
}
static void *_p_FIX__RiskSecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityGroup *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StartDate *) x));
}
static void *_p_FIX__RiskSeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSeniority *) x));
}
static void *_p_FIX__RelationshipRiskSecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityGroup *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__RelationshipRiskSeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSeniority *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardStartDate *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Seniority *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListID *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListID *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListExecInst *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AdvRefID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::URLLink *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__RelationshipRiskCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskCFICode *) x));
}
static void *_p_FIX__RiskCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCFICode *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RoutingID *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__PartyDetailsListReportIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartyDetailsListReportID *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIid *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TimeUnit *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExecBroker *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContraBroker *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NewsID *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Subject *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EventText *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RefAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNum *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__RiskSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityType *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityType *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__RelationshipRiskSecurityTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityType *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RejectText *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIShares *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteID *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TierCode *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Headline *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistEmail *) x));
}
static void *_p_FIX__RiskSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityAltIDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__RiskSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__RelationshipRiskSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityAltIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InputSource *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDay *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosType *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ComplianceID *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ListName *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__ContextPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContextPartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedContextPartySubID *) x));
}
static void *_p_FIX__RelatedPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelatedPartySubID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryID *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PartySubID *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::XmlData *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDStreamID *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReqID *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollRptID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TestReqID *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::IOIRefID *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LanguageCode *) x));
}
static void *_p_FIX__RiskSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__RelationshipRiskSymbolSfxTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSymbolSfx *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AllocAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__AccountTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Account *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Issuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssuer *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__RelationshipRiskSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__RiskSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecuritySubType *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Scope *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosAmtType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AdvTransType *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__RiskWarningLevelNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskWarningLevelName *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskWarningLevelName *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CPRegType *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegPool *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RawData *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketID *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DlvyInst *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DeskID *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NewsRefID *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementID *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationValue *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MDMkt *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuantityDate *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__RelationshipRiskMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskMaturityTime *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__RiskMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskMaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityTime *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::Designation *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExDestination *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNo *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EventDate *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MatchType *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CorporateAction *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlLocation *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlType *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentSettlTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskInstrumentSettlType *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDetls *) x));
}
static void *_p_FIX__RiskInstrumentSettlTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskInstrumentSettlType *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegRefID *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BookingRefID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecureData *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__RiskSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskSecurityExchange *) x));
}
static void *_p_FIX__RelationshipRiskSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskSecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__RiskRestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskRestructuringType *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RestructuringType *) x));
}
static void *_p_FIX__RelationshipRiskRestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskRestructuringType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ExpireDate *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::CollRespID *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RptSys *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__RiskProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskProductComplex *) x));
}
static void *_p_FIX__RelationshipRiskProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskProductComplex *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligID *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RegistID *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RelationshipRiskMaturityMonthYear *) x));
}
static void *_p_FIX__RiskMaturityMonthYearTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::RiskMaturityMonthYear *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__StringField(void *x) {
    return (void *)((FIX::StringField *)  ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__SynchronizedApplicationTo_p_FIX__Application(void *x) {
    return (void *)((FIX::Application *)  ((FIX::SynchronizedApplication *) x));
}
static void *_p_FIX__NullApplicationTo_p_FIX__Application(void *x) {
    return (void *)((FIX::Application *)  ((FIX::NullApplication *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__SocketException(void *x) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__SocketException(void *x) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__SocketException(void *x) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__RequiredTagMissingTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RequiredTagMissing *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__InvalidTagNumberTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidTagNumber *) x));
}
static void *_p_FIX__RejectLogonTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RejectLogon *) x));
}
static void *_p_FIX__IncorrectDataFormatTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectDataFormat *) x));
}
static void *_p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::TagNotDefinedForMessage *) x));
}
static void *_p_FIX__InvalidMessageTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessage *) x));
}
static void *_p_FIX__RuntimeErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RuntimeError *) x));
}
static void *_p_FIX__MessageParseErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::MessageParseError *) x));
}
static void *_p_FIX__DuplicateFieldNumberTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::DuplicateFieldNumber *) x));
}
static void *_p_FIX__DoNotSendTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::DoNotSend *) x));
}
static void *_p_FIX__FieldNotFoundTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::FieldNotFound *) x));
}
static void *_p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::DataDictionaryNotFound *) x));
}
static void *_p_FIX__SessionNotFoundTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::SessionNotFound *) x));
}
static void *_p_FIX__IOExceptionTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IOException *) x));
}
static void *_p_FIX__SocketExceptionTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::SocketException *) x));
}
static void *_p_FIX__ConfigErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::ConfigError *) x));
}
static void *_p_FIX__InvalidMessageTypeTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessageType *) x));
}
static void *_p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedMessageType *) x));
}
static void *_p_FIX__UnsupportedVersionTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedVersion *) x));
}
static void *_p_FIX__IncorrectTagValueTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectTagValue *) x));
}
static void *_p_FIX__NoTagValueTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::NoTagValue *) x));
}
static void *_p_FIX__TagOutOfOrderTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::TagOutOfOrder *) x));
}
static void *_p_FIX__RepeatedTagTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatedTag *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__FieldConvertErrorTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::FieldConvertError *) x));
}
static void *_p_FIX__IncorrectMessageStructureTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectMessageStructure *) x));
}
static void *_p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception(void *x) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatingGroupCountMismatch *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPositions *) x));
}
static void *_p_FIX__NoRelationshipRiskWarningLevelsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskWarningLevels *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoRiskWarningLevelsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskWarningLevels *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RptSeq *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumBidders *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegModel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideValueInd *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContAmts *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskInstruments *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__NoRiskInstrumentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskInstruments *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::HopRefID *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrders *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Adjustment *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListStatusType *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExpType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__RelationshipRiskLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskLimitType *) x));
}
static void *_p_FIX__RiskLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskLimitType *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentOperatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskInstrumentOperator *) x));
}
static void *_p_FIX__RiskInstrumentOperatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskInstrumentOperator *) x));
}
static void *_p_FIX__RelationshipRiskProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskProduct *) x));
}
static void *_p_FIX__RiskProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskProduct *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegProduct *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoCapacities *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Product *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegPriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RateSourceType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TerminationType *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoRiskSecurityAltIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskSecurityAltID *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__DerivativeSecurityListRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeSecurityListRequestType *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StatsType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__RiskPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskPutOrCall *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PutOrCall *) x));
}
static void *_p_FIX__RelationshipRiskPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskPutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContingencyType *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SessionStatus *) x));
}
static void *_p_FIX__SecDefStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecDefStatus *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UserStatus *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollStatus *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocType *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MarketDepth *) x));
}
static void *_p_FIX__NoPartyRelationshipsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyRelationships *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollApplType *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumTickets *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegSwapType *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelay *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrades *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ModelType *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoHops *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocReportType *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReportType *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CrossType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TickRuleType *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRateSources *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__RelatedPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedPartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__RelatedContextPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedContextPartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__RequestedPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RequestedPartyRole *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__ContextPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContextPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__RelationshipRiskEncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelationshipRiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__RiskEncodedSecurityDescLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RiskEncodedSecurityDescLen *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegNumber *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StatusValue *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideQty *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__NoRelatedPartyAltSubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartyAltSubIDs *) x));
}
static void *_p_FIX__NoPartyAltSubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyAltSubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoContextPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContextPartySubIDs *) x));
}
static void *_p_FIX__NoRelatedPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoRelatedContextPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedContextPartySubIDs *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegMoveType *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoFills *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SellerDays *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ListMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocMethod *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAllocs *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoExpiration *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoContextPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoContextPartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoRelatedPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegs *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__NoRelatedContextPartyIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedContextPartyIDs *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__NoPartyListTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyList *) x));
}
static void *_p_FIX__TotNoPartyListTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoPartyList *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMode *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PegScope *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDReportID *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteType *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideLastQty *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__NoRequestedPartyRolesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRequestedPartyRoles *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QtyType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::QuantityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__NoPartyListResponseTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyListResponseTypes *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CPProgram *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__PartyListResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyListResponseType *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RespondentType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EventType *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RateSource *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BidType *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDates *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OwnerType *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSides *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDOriginType *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStipulations *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRpts *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContAmtType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosTransType *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__RelatedPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedPartySubIDType *) x));
}
static void *_p_FIX__PartyAltSubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyAltSubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__RelatedPartyAltSubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedPartyAltSubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__NoRiskLimitsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRiskLimits *) x));
}
static void *_p_FIX__NoRelationshipRiskLimitsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelationshipRiskLimits *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__ContextPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ContextPartySubIDType *) x));
}
static void *_p_FIX__RelatedContextPartySubIDTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RelatedContextPartySubIDType *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReqType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NewsCategory *) x));
}
static void *_p_FIX__PartyRelationshipTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyRelationship *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__NoRelatedPartyAltIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedPartyAltIDs *) x));
}
static void *_p_FIX__NoPartyAltIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyAltIDs *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NewsRefType *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::LinesOfText *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionScope *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoTickRules *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikes *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefTagID *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecs *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RoutingType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BookingType *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__PartyDetailsRequestResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PartyDetailsRequestResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqResult *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::SignatureLength *) x));
}
static void *_p_FIX__EncodedSymbolLenTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSymbolLen *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ApplExtID *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__IntField(void *x) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EventTime *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExpireTime *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::StrikeTime *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransactTime *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SendingTime *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__UtcTimeStampField(void *x) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::DueToRelated *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ForexReq *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__RiskFlexibleIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::RiskFlexibleIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__RelationshipRiskFlexibleIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::RelationshipRiskFlexibleIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportToExch *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LocateReqd *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PossResend *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::OddLot *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::LastFragment *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__BoolField(void *x) {
    return (void *)((FIX::BoolField *)  ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__UtcTimeOnlyField(void *x) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__UtcDateField(void *x) {
    return (void *)((FIX::UtcDateField *)  ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__UtcDateField(void *x) {
    return (void *)((FIX::UtcDateField *)  ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ReportedPx *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RatioQty *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LeavesQty *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegFactor *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FloorPrice *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StopPx *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__RiskLimitAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskLimitAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__RelationshipRiskLimitAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskLimitAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgParPx *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ShortQty *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinQty *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Commission *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SharedCommission *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__RiskInstrumentMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskInstrumentMultiplier *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__RelationshipRiskInstrumentMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskInstrumentMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CapPrice *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferYield *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidPx *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegDifference *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighPx *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastParPx *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SellVolume *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RndPx *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastQty *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayQty *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Spread *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FirstPx *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradeVolume *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BuyVolume *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidPx *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeValue *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PosAmt *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidYield *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidYield *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidPx *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillQty *) x));
}
static void *_p_FIX__PriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndCash *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Concession *) x));
}
static void *_p_FIX__RiskCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskCouponRate *) x));
}
static void *_p_FIX__RelationshipRiskCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskCouponRate *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CcyAmt *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastShares *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Shares *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPrice *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegQty *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxShow *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundLot *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RefreshQty *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExpQty *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginExcess *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TickIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DividendYield *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CxlQty *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocShares *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__YieldTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Yield *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceDelta *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Volatility *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSize *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillPx *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__Price2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price2 *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgPx *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlPrice *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CumQty *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OpenInterest *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LongQty *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastPx *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSize *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::FairValue *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowPx *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue2 *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktBidPx *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartCash *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinLotSize *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocPrice *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__FactorTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::Factor *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayCumQty *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::CrossPercent *) x));
}
static void *_p_FIX__RiskWarningLevelPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskWarningLevelPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderPercent *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__RelationshipRiskWarningLevelPercentTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::RelationshipRiskWarningLevelPercent *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__DoubleField(void *x) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDSecSize *) x));
}
static swig_type_info _swigt__p_ApplVerID = {"_p_ApplVerID", "ApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Application = {"_p_Application", "Application *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BeginString = {"_p_BeginString", "BeginString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DOMDocumentPtr = {"_p_DOMDocumentPtr", "DOMDocumentPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Data = {"_p_Data", "Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionary = {"_p_DataDictionary", "DataDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionaryProvider = {"_p_DataDictionaryProvider", "DataDictionaryProvider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DateTime = {"_p_DateTime", "DateTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dictionaries = {"_p_Dictionaries", "Dictionaries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DoubleField = {"_p_DoubleField", "DoubleField *|PercentageField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AMT = {"_p_FIX__AMT", "FIX::AMT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Acceptor = {"_p_FIX__Acceptor", "FIX::Acceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Account = {"_p_FIX__Account", "FIX::Account *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccountType = {"_p_FIX__AccountType", "FIX::AccountType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccruedInterestAmt = {"_p_FIX__AccruedInterestAmt", "FIX::AccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccruedInterestRate = {"_p_FIX__AccruedInterestRate", "FIX::AccruedInterestRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AcctIDSource = {"_p_FIX__AcctIDSource", "FIX::AcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Adjustment = {"_p_FIX__Adjustment", "FIX::Adjustment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdjustmentType = {"_p_FIX__AdjustmentType", "FIX::AdjustmentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvId = {"_p_FIX__AdvId", "FIX::AdvId *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvRefID = {"_p_FIX__AdvRefID", "FIX::AdvRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvSide = {"_p_FIX__AdvSide", "FIX::AdvSide *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvTransType = {"_p_FIX__AdvTransType", "FIX::AdvTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffectedOrderID = {"_p_FIX__AffectedOrderID", "FIX::AffectedOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffectedSecondaryOrderID = {"_p_FIX__AffectedSecondaryOrderID", "FIX::AffectedSecondaryOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffirmStatus = {"_p_FIX__AffirmStatus", "FIX::AffirmStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AggregatedBook = {"_p_FIX__AggregatedBook", "FIX::AggregatedBook *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AggressorIndicator = {"_p_FIX__AggressorIndicator", "FIX::AggressorIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementCurrency = {"_p_FIX__AgreementCurrency", "FIX::AgreementCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementDate = {"_p_FIX__AgreementDate", "FIX::AgreementDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementDesc = {"_p_FIX__AgreementDesc", "FIX::AgreementDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementID = {"_p_FIX__AgreementID", "FIX::AgreementID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccount = {"_p_FIX__AllocAccount", "FIX::AllocAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccountType = {"_p_FIX__AllocAccountType", "FIX::AllocAccountType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccruedInterestAmt = {"_p_FIX__AllocAccruedInterestAmt", "FIX::AllocAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAcctIDSource = {"_p_FIX__AllocAcctIDSource", "FIX::AllocAcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAvgPx = {"_p_FIX__AllocAvgPx", "FIX::AllocAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocCancReplaceReason = {"_p_FIX__AllocCancReplaceReason", "FIX::AllocCancReplaceReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocClearingFeeIndicator = {"_p_FIX__AllocClearingFeeIndicator", "FIX::AllocClearingFeeIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocCustomerCapacity = {"_p_FIX__AllocCustomerCapacity", "FIX::AllocCustomerCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocHandlInst = {"_p_FIX__AllocHandlInst", "FIX::AllocHandlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocID = {"_p_FIX__AllocID", "FIX::AllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocInterestAtMaturity = {"_p_FIX__AllocInterestAtMaturity", "FIX::AllocInterestAtMaturity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocIntermedReqType = {"_p_FIX__AllocIntermedReqType", "FIX::AllocIntermedReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocLinkID = {"_p_FIX__AllocLinkID", "FIX::AllocLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocLinkType = {"_p_FIX__AllocLinkType", "FIX::AllocLinkType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocMethod = {"_p_FIX__AllocMethod", "FIX::AllocMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocNetMoney = {"_p_FIX__AllocNetMoney", "FIX::AllocNetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocNoOrdersType = {"_p_FIX__AllocNoOrdersType", "FIX::AllocNoOrdersType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocPositionEffect = {"_p_FIX__AllocPositionEffect", "FIX::AllocPositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocPrice = {"_p_FIX__AllocPrice", "FIX::AllocPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocQty = {"_p_FIX__AllocQty", "FIX::AllocQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocRejCode = {"_p_FIX__AllocRejCode", "FIX::AllocRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportID = {"_p_FIX__AllocReportID", "FIX::AllocReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportRefID = {"_p_FIX__AllocReportRefID", "FIX::AllocReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportType = {"_p_FIX__AllocReportType", "FIX::AllocReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlCurrAmt = {"_p_FIX__AllocSettlCurrAmt", "FIX::AllocSettlCurrAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlCurrency = {"_p_FIX__AllocSettlCurrency", "FIX::AllocSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlInstType = {"_p_FIX__AllocSettlInstType", "FIX::AllocSettlInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocShares = {"_p_FIX__AllocShares", "FIX::AllocShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocStatus = {"_p_FIX__AllocStatus", "FIX::AllocStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocText = {"_p_FIX__AllocText", "FIX::AllocText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocTransType = {"_p_FIX__AllocTransType", "FIX::AllocTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocType = {"_p_FIX__AllocType", "FIX::AllocType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessCurr = {"_p_FIX__AllowableOneSidednessCurr", "FIX::AllowableOneSidednessCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessPct = {"_p_FIX__AllowableOneSidednessPct", "FIX::AllowableOneSidednessPct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessValue = {"_p_FIX__AllowableOneSidednessValue", "FIX::AllowableOneSidednessValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AltMDSourceID = {"_p_FIX__AltMDSourceID", "FIX::AltMDSourceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplBegSeqNum = {"_p_FIX__ApplBegSeqNum", "FIX::ApplBegSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplEndSeqNum = {"_p_FIX__ApplEndSeqNum", "FIX::ApplEndSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplExtID = {"_p_FIX__ApplExtID", "FIX::ApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplID = {"_p_FIX__ApplID", "FIX::ApplID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplLastSeqNum = {"_p_FIX__ApplLastSeqNum", "FIX::ApplLastSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplNewSeqNum = {"_p_FIX__ApplNewSeqNum", "FIX::ApplNewSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueAction = {"_p_FIX__ApplQueueAction", "FIX::ApplQueueAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueDepth = {"_p_FIX__ApplQueueDepth", "FIX::ApplQueueDepth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueMax = {"_p_FIX__ApplQueueMax", "FIX::ApplQueueMax *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueResolution = {"_p_FIX__ApplQueueResolution", "FIX::ApplQueueResolution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReportID = {"_p_FIX__ApplReportID", "FIX::ApplReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReportType = {"_p_FIX__ApplReportType", "FIX::ApplReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReqID = {"_p_FIX__ApplReqID", "FIX::ApplReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReqType = {"_p_FIX__ApplReqType", "FIX::ApplReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResendFlag = {"_p_FIX__ApplResendFlag", "FIX::ApplResendFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseError = {"_p_FIX__ApplResponseError", "FIX::ApplResponseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseID = {"_p_FIX__ApplResponseID", "FIX::ApplResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseType = {"_p_FIX__ApplResponseType", "FIX::ApplResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplSeqNum = {"_p_FIX__ApplSeqNum", "FIX::ApplSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplTotalMessageCount = {"_p_FIX__ApplTotalMessageCount", "FIX::ApplTotalMessageCount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplVerID = {"_p_FIX__ApplVerID", "FIX::ApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Application = {"_p_FIX__Application", "FIX::Application *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AsOfIndicator = {"_p_FIX__AsOfIndicator", "FIX::AsOfIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AsgnReqID = {"_p_FIX__AsgnReqID", "FIX::AsgnReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AsgnRptID = {"_p_FIX__AsgnRptID", "FIX::AsgnRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AssignmentMethod = {"_p_FIX__AssignmentMethod", "FIX::AssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AssignmentUnit = {"_p_FIX__AssignmentUnit", "FIX::AssignmentUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AttachmentPoint = {"_p_FIX__AttachmentPoint", "FIX::AttachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AutoAcceptIndicator = {"_p_FIX__AutoAcceptIndicator", "FIX::AutoAcceptIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgParPx = {"_p_FIX__AvgParPx", "FIX::AvgParPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPrxPrecision = {"_p_FIX__AvgPrxPrecision", "FIX::AvgPrxPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPx = {"_p_FIX__AvgPx", "FIX::AvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPxIndicator = {"_p_FIX__AvgPxIndicator", "FIX::AvgPxIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPxPrecision = {"_p_FIX__AvgPxPrecision", "FIX::AvgPxPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BOOLEAN = {"_p_FIX__BOOLEAN", "FIX::BOOLEAN *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisFeatureDate = {"_p_FIX__BasisFeatureDate", "FIX::BasisFeatureDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisFeaturePrice = {"_p_FIX__BasisFeaturePrice", "FIX::BasisFeaturePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisPxType = {"_p_FIX__BasisPxType", "FIX::BasisPxType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BeginSeqNo = {"_p_FIX__BeginSeqNo", "FIX::BeginSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BeginString = {"_p_FIX__BeginString", "FIX::BeginString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Benchmark = {"_p_FIX__Benchmark", "FIX::Benchmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurveCurrency = {"_p_FIX__BenchmarkCurveCurrency", "FIX::BenchmarkCurveCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurveName = {"_p_FIX__BenchmarkCurveName", "FIX::BenchmarkCurveName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurvePoint = {"_p_FIX__BenchmarkCurvePoint", "FIX::BenchmarkCurvePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkPrice = {"_p_FIX__BenchmarkPrice", "FIX::BenchmarkPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkPriceType = {"_p_FIX__BenchmarkPriceType", "FIX::BenchmarkPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkSecurityID = {"_p_FIX__BenchmarkSecurityID", "FIX::BenchmarkSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkSecurityIDSource = {"_p_FIX__BenchmarkSecurityIDSource", "FIX::BenchmarkSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidDescriptor = {"_p_FIX__BidDescriptor", "FIX::BidDescriptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidDescriptorType = {"_p_FIX__BidDescriptorType", "FIX::BidDescriptorType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidForwardPoints = {"_p_FIX__BidForwardPoints", "FIX::BidForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidForwardPoints2 = {"_p_FIX__BidForwardPoints2", "FIX::BidForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidID = {"_p_FIX__BidID", "FIX::BidID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidPx = {"_p_FIX__BidPx", "FIX::BidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidRequestTransType = {"_p_FIX__BidRequestTransType", "FIX::BidRequestTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSize = {"_p_FIX__BidSize", "FIX::BidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSpotRate = {"_p_FIX__BidSpotRate", "FIX::BidSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSwapPoints = {"_p_FIX__BidSwapPoints", "FIX::BidSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidTradeType = {"_p_FIX__BidTradeType", "FIX::BidTradeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidType = {"_p_FIX__BidType", "FIX::BidType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidYield = {"_p_FIX__BidYield", "FIX::BidYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BodyLength = {"_p_FIX__BodyLength", "FIX::BodyLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingRefID = {"_p_FIX__BookingRefID", "FIX::BookingRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingType = {"_p_FIX__BookingType", "FIX::BookingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingUnit = {"_p_FIX__BookingUnit", "FIX::BookingUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BoolField = {"_p_FIX__BoolField", "FIX::BoolField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BrokerOfCredit = {"_p_FIX__BrokerOfCredit", "FIX::BrokerOfCredit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BusinessRejectReason = {"_p_FIX__BusinessRejectReason", "FIX::BusinessRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BusinessRejectRefID = {"_p_FIX__BusinessRejectRefID", "FIX::BusinessRejectRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BuyVolume = {"_p_FIX__BuyVolume", "FIX::BuyVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CFICode = {"_p_FIX__CFICode", "FIX::CFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CHAR = {"_p_FIX__CHAR", "FIX::CHAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__COUNTRY = {"_p_FIX__COUNTRY", "FIX::COUNTRY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CPProgram = {"_p_FIX__CPProgram", "FIX::CPProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CPRegType = {"_p_FIX__CPRegType", "FIX::CPRegType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CURRENCY = {"_p_FIX__CURRENCY", "FIX::CURRENCY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CalculatedCcyLastQty = {"_p_FIX__CalculatedCcyLastQty", "FIX::CalculatedCcyLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CancellationRights = {"_p_FIX__CancellationRights", "FIX::CancellationRights *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CapPrice = {"_p_FIX__CapPrice", "FIX::CapPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardExpDate = {"_p_FIX__CardExpDate", "FIX::CardExpDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardHolderName = {"_p_FIX__CardHolderName", "FIX::CardHolderName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardIssNo = {"_p_FIX__CardIssNo", "FIX::CardIssNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardIssNum = {"_p_FIX__CardIssNum", "FIX::CardIssNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardNumber = {"_p_FIX__CardNumber", "FIX::CardNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardStartDate = {"_p_FIX__CardStartDate", "FIX::CardStartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentAcctName = {"_p_FIX__CashDistribAgentAcctName", "FIX::CashDistribAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentAcctNumber = {"_p_FIX__CashDistribAgentAcctNumber", "FIX::CashDistribAgentAcctNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentCode = {"_p_FIX__CashDistribAgentCode", "FIX::CashDistribAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentName = {"_p_FIX__CashDistribAgentName", "FIX::CashDistribAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribCurr = {"_p_FIX__CashDistribCurr", "FIX::CashDistribCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribPayRef = {"_p_FIX__CashDistribPayRef", "FIX::CashDistribPayRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashMargin = {"_p_FIX__CashMargin", "FIX::CashMargin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashOrderQty = {"_p_FIX__CashOrderQty", "FIX::CashOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashOutstanding = {"_p_FIX__CashOutstanding", "FIX::CashOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentAcctName = {"_p_FIX__CashSettlAgentAcctName", "FIX::CashSettlAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentAcctNum = {"_p_FIX__CashSettlAgentAcctNum", "FIX::CashSettlAgentAcctNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentCode = {"_p_FIX__CashSettlAgentCode", "FIX::CashSettlAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentContactName = {"_p_FIX__CashSettlAgentContactName", "FIX::CashSettlAgentContactName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentContactPhone = {"_p_FIX__CashSettlAgentContactPhone", "FIX::CashSettlAgentContactPhone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentName = {"_p_FIX__CashSettlAgentName", "FIX::CashSettlAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CcyAmt = {"_p_FIX__CcyAmt", "FIX::CcyAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CharField = {"_p_FIX__CharField", "FIX::CharField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CheckSum = {"_p_FIX__CheckSum", "FIX::CheckSum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CheckSumField = {"_p_FIX__CheckSumField", "FIX::CheckSumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClOrdID = {"_p_FIX__ClOrdID", "FIX::ClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClOrdLinkID = {"_p_FIX__ClOrdLinkID", "FIX::ClOrdLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingAccount = {"_p_FIX__ClearingAccount", "FIX::ClearingAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingBusinessDate = {"_p_FIX__ClearingBusinessDate", "FIX::ClearingBusinessDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingFeeIndicator = {"_p_FIX__ClearingFeeIndicator", "FIX::ClearingFeeIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingFirm = {"_p_FIX__ClearingFirm", "FIX::ClearingFirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingInstruction = {"_p_FIX__ClearingInstruction", "FIX::ClearingInstruction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClientBidID = {"_p_FIX__ClientBidID", "FIX::ClientBidID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClientID = {"_p_FIX__ClientID", "FIX::ClientID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAction = {"_p_FIX__CollAction", "FIX::CollAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollApplType = {"_p_FIX__CollApplType", "FIX::CollApplType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnID = {"_p_FIX__CollAsgnID", "FIX::CollAsgnID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnReason = {"_p_FIX__CollAsgnReason", "FIX::CollAsgnReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRefID = {"_p_FIX__CollAsgnRefID", "FIX::CollAsgnRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRejectReason = {"_p_FIX__CollAsgnRejectReason", "FIX::CollAsgnRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRespType = {"_p_FIX__CollAsgnRespType", "FIX::CollAsgnRespType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnTransType = {"_p_FIX__CollAsgnTransType", "FIX::CollAsgnTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryID = {"_p_FIX__CollInquiryID", "FIX::CollInquiryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryQualifier = {"_p_FIX__CollInquiryQualifier", "FIX::CollInquiryQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryResult = {"_p_FIX__CollInquiryResult", "FIX::CollInquiryResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryStatus = {"_p_FIX__CollInquiryStatus", "FIX::CollInquiryStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollReqID = {"_p_FIX__CollReqID", "FIX::CollReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollRespID = {"_p_FIX__CollRespID", "FIX::CollRespID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollRptID = {"_p_FIX__CollRptID", "FIX::CollRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollStatus = {"_p_FIX__CollStatus", "FIX::CollStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CommCurrency = {"_p_FIX__CommCurrency", "FIX::CommCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CommType = {"_p_FIX__CommType", "FIX::CommType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Commission = {"_p_FIX__Commission", "FIX::Commission *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventCondition = {"_p_FIX__ComplexEventCondition", "FIX::ComplexEventCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventEndDate = {"_p_FIX__ComplexEventEndDate", "FIX::ComplexEventEndDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventEndTime = {"_p_FIX__ComplexEventEndTime", "FIX::ComplexEventEndTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPrice = {"_p_FIX__ComplexEventPrice", "FIX::ComplexEventPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceBoundaryMethod = {"_p_FIX__ComplexEventPriceBoundaryMethod", "FIX::ComplexEventPriceBoundaryMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceBoundaryPrecision = {"_p_FIX__ComplexEventPriceBoundaryPrecision", "FIX::ComplexEventPriceBoundaryPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceTimeType = {"_p_FIX__ComplexEventPriceTimeType", "FIX::ComplexEventPriceTimeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventStartDate = {"_p_FIX__ComplexEventStartDate", "FIX::ComplexEventStartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventStartTime = {"_p_FIX__ComplexEventStartTime", "FIX::ComplexEventStartTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventType = {"_p_FIX__ComplexEventType", "FIX::ComplexEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexOptPayoutAmount = {"_p_FIX__ComplexOptPayoutAmount", "FIX::ComplexOptPayoutAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplianceID = {"_p_FIX__ComplianceID", "FIX::ComplianceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Concession = {"_p_FIX__Concession", "FIX::Concession *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfigError = {"_p_FIX__ConfigError", "FIX::ConfigError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmID = {"_p_FIX__ConfirmID", "FIX::ConfirmID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmRefID = {"_p_FIX__ConfirmRefID", "FIX::ConfirmRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmRejReason = {"_p_FIX__ConfirmRejReason", "FIX::ConfirmRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmReqID = {"_p_FIX__ConfirmReqID", "FIX::ConfirmReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmStatus = {"_p_FIX__ConfirmStatus", "FIX::ConfirmStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmTransType = {"_p_FIX__ConfirmTransType", "FIX::ConfirmTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmType = {"_p_FIX__ConfirmType", "FIX::ConfirmType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtCurr = {"_p_FIX__ContAmtCurr", "FIX::ContAmtCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtType = {"_p_FIX__ContAmtType", "FIX::ContAmtType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtValue = {"_p_FIX__ContAmtValue", "FIX::ContAmtValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContIntRptID = {"_p_FIX__ContIntRptID", "FIX::ContIntRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartyID = {"_p_FIX__ContextPartyID", "FIX::ContextPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartyIDSource = {"_p_FIX__ContextPartyIDSource", "FIX::ContextPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartyRole = {"_p_FIX__ContextPartyRole", "FIX::ContextPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartySubID = {"_p_FIX__ContextPartySubID", "FIX::ContextPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContextPartySubIDType = {"_p_FIX__ContextPartySubIDType", "FIX::ContextPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContingencyType = {"_p_FIX__ContingencyType", "FIX::ContingencyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraBroker = {"_p_FIX__ContraBroker", "FIX::ContraBroker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraLegRefID = {"_p_FIX__ContraLegRefID", "FIX::ContraLegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTradeQty = {"_p_FIX__ContraTradeQty", "FIX::ContraTradeQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTradeTime = {"_p_FIX__ContraTradeTime", "FIX::ContraTradeTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTrader = {"_p_FIX__ContraTrader", "FIX::ContraTrader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractMultiplier = {"_p_FIX__ContractMultiplier", "FIX::ContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractMultiplierUnit = {"_p_FIX__ContractMultiplierUnit", "FIX::ContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractSettlMonth = {"_p_FIX__ContractSettlMonth", "FIX::ContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraryInstructionIndicator = {"_p_FIX__ContraryInstructionIndicator", "FIX::ContraryInstructionIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CopyMsgIndicator = {"_p_FIX__CopyMsgIndicator", "FIX::CopyMsgIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CorporateAction = {"_p_FIX__CorporateAction", "FIX::CorporateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Country = {"_p_FIX__Country", "FIX::Country *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CountryOfIssue = {"_p_FIX__CountryOfIssue", "FIX::CountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CouponPaymentDate = {"_p_FIX__CouponPaymentDate", "FIX::CouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CouponRate = {"_p_FIX__CouponRate", "FIX::CouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CoveredOrUncovered = {"_p_FIX__CoveredOrUncovered", "FIX::CoveredOrUncovered *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CreditRating = {"_p_FIX__CreditRating", "FIX::CreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossID = {"_p_FIX__CrossID", "FIX::CrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossPercent = {"_p_FIX__CrossPercent", "FIX::CrossPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossPrioritization = {"_p_FIX__CrossPrioritization", "FIX::CrossPrioritization *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossType = {"_p_FIX__CrossType", "FIX::CrossType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CstmApplVerID = {"_p_FIX__CstmApplVerID", "FIX::CstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CumQty = {"_p_FIX__CumQty", "FIX::CumQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Currency = {"_p_FIX__Currency", "FIX::Currency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CurrencyRatio = {"_p_FIX__CurrencyRatio", "FIX::CurrencyRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustDirectedOrder = {"_p_FIX__CustDirectedOrder", "FIX::CustDirectedOrder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustOrderCapacity = {"_p_FIX__CustOrderCapacity", "FIX::CustOrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustOrderHandlingInst = {"_p_FIX__CustOrderHandlingInst", "FIX::CustOrderHandlingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustomerOrFirm = {"_p_FIX__CustomerOrFirm", "FIX::CustomerOrFirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlQty = {"_p_FIX__CxlQty", "FIX::CxlQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlRejReason = {"_p_FIX__CxlRejReason", "FIX::CxlRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlRejResponseTo = {"_p_FIX__CxlRejResponseTo", "FIX::CxlRejResponseTo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlType = {"_p_FIX__CxlType", "FIX::CxlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DATA = {"_p_FIX__DATA", "FIX::DATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DAYOFMONTH = {"_p_FIX__DAYOFMONTH", "FIX::DAYOFMONTH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DKReason = {"_p_FIX__DKReason", "FIX::DKReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DataDictionary = {"_p_FIX__DataDictionary", "FIX::DataDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DataDictionaryNotFound = {"_p_FIX__DataDictionaryNotFound", "FIX::DataDictionaryNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DateOfBirth = {"_p_FIX__DateOfBirth", "FIX::DateOfBirth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DatedDate = {"_p_FIX__DatedDate", "FIX::DatedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayAvgPx = {"_p_FIX__DayAvgPx", "FIX::DayAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayBookingInst = {"_p_FIX__DayBookingInst", "FIX::DayBookingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayCumQty = {"_p_FIX__DayCumQty", "FIX::DayCumQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayOrderQty = {"_p_FIX__DayOrderQty", "FIX::DayOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DealingCapacity = {"_p_FIX__DealingCapacity", "FIX::DealingCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefBidSize = {"_p_FIX__DefBidSize", "FIX::DefBidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefOfferSize = {"_p_FIX__DefOfferSize", "FIX::DefOfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultApplExtID = {"_p_FIX__DefaultApplExtID", "FIX::DefaultApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultApplVerID = {"_p_FIX__DefaultApplVerID", "FIX::DefaultApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultCstmApplVerID = {"_p_FIX__DefaultCstmApplVerID", "FIX::DefaultCstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultVerIndicator = {"_p_FIX__DefaultVerIndicator", "FIX::DefaultVerIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeleteReason = {"_p_FIX__DeleteReason", "FIX::DeleteReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToCompID = {"_p_FIX__DeliverToCompID", "FIX::DeliverToCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToLocationID = {"_p_FIX__DeliverToLocationID", "FIX::DeliverToLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToSubID = {"_p_FIX__DeliverToSubID", "FIX::DeliverToSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryDate = {"_p_FIX__DeliveryDate", "FIX::DeliveryDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryForm = {"_p_FIX__DeliveryForm", "FIX::DeliveryForm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryType = {"_p_FIX__DeliveryType", "FIX::DeliveryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivFlexProductEligibilityIndicator = {"_p_FIX__DerivFlexProductEligibilityIndicator", "FIX::DerivFlexProductEligibilityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCFICode = {"_p_FIX__DerivativeCFICode", "FIX::DerivativeCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCapPrice = {"_p_FIX__DerivativeCapPrice", "FIX::DerivativeCapPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractMultiplier = {"_p_FIX__DerivativeContractMultiplier", "FIX::DerivativeContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractMultiplierUnit = {"_p_FIX__DerivativeContractMultiplierUnit", "FIX::DerivativeContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractSettlMonth = {"_p_FIX__DerivativeContractSettlMonth", "FIX::DerivativeContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCountryOfIssue = {"_p_FIX__DerivativeCountryOfIssue", "FIX::DerivativeCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedIssuer = {"_p_FIX__DerivativeEncodedIssuer", "FIX::DerivativeEncodedIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedIssuerLen = {"_p_FIX__DerivativeEncodedIssuerLen", "FIX::DerivativeEncodedIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedSecurityDesc = {"_p_FIX__DerivativeEncodedSecurityDesc", "FIX::DerivativeEncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedSecurityDescLen = {"_p_FIX__DerivativeEncodedSecurityDescLen", "FIX::DerivativeEncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventDate = {"_p_FIX__DerivativeEventDate", "FIX::DerivativeEventDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventPx = {"_p_FIX__DerivativeEventPx", "FIX::DerivativeEventPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventText = {"_p_FIX__DerivativeEventText", "FIX::DerivativeEventText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventTime = {"_p_FIX__DerivativeEventTime", "FIX::DerivativeEventTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventType = {"_p_FIX__DerivativeEventType", "FIX::DerivativeEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeExerciseStyle = {"_p_FIX__DerivativeExerciseStyle", "FIX::DerivativeExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFloorPrice = {"_p_FIX__DerivativeFloorPrice", "FIX::DerivativeFloorPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFlowScheduleType = {"_p_FIX__DerivativeFlowScheduleType", "FIX::DerivativeFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFuturesValuationMethod = {"_p_FIX__DerivativeFuturesValuationMethod", "FIX::DerivativeFuturesValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrAttribType = {"_p_FIX__DerivativeInstrAttribType", "FIX::DerivativeInstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrAttribValue = {"_p_FIX__DerivativeInstrAttribValue", "FIX::DerivativeInstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrRegistry = {"_p_FIX__DerivativeInstrRegistry", "FIX::DerivativeInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrmtAssignmentMethod = {"_p_FIX__DerivativeInstrmtAssignmentMethod", "FIX::DerivativeInstrmtAssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyID = {"_p_FIX__DerivativeInstrumentPartyID", "FIX::DerivativeInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyIDSource = {"_p_FIX__DerivativeInstrumentPartyIDSource", "FIX::DerivativeInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyRole = {"_p_FIX__DerivativeInstrumentPartyRole", "FIX::DerivativeInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartySubID = {"_p_FIX__DerivativeInstrumentPartySubID", "FIX::DerivativeInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartySubIDType = {"_p_FIX__DerivativeInstrumentPartySubIDType", "FIX::DerivativeInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeIssueDate = {"_p_FIX__DerivativeIssueDate", "FIX::DerivativeIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeIssuer = {"_p_FIX__DerivativeIssuer", "FIX::DerivativeIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeListMethod = {"_p_FIX__DerivativeListMethod", "FIX::DerivativeListMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeLocaleOfIssue = {"_p_FIX__DerivativeLocaleOfIssue", "FIX::DerivativeLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityDate = {"_p_FIX__DerivativeMaturityDate", "FIX::DerivativeMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityMonthYear = {"_p_FIX__DerivativeMaturityMonthYear", "FIX::DerivativeMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityTime = {"_p_FIX__DerivativeMaturityTime", "FIX::DerivativeMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMinPriceIncrement = {"_p_FIX__DerivativeMinPriceIncrement", "FIX::DerivativeMinPriceIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMinPriceIncrementAmount = {"_p_FIX__DerivativeMinPriceIncrementAmount", "FIX::DerivativeMinPriceIncrementAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeNTPositionLimit = {"_p_FIX__DerivativeNTPositionLimit", "FIX::DerivativeNTPositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeOptAttribute = {"_p_FIX__DerivativeOptAttribute", "FIX::DerivativeOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeOptPayAmount = {"_p_FIX__DerivativeOptPayAmount", "FIX::DerivativeOptPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePositionLimit = {"_p_FIX__DerivativePositionLimit", "FIX::DerivativePositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceQuoteMethod = {"_p_FIX__DerivativePriceQuoteMethod", "FIX::DerivativePriceQuoteMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceUnitOfMeasure = {"_p_FIX__DerivativePriceUnitOfMeasure", "FIX::DerivativePriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceUnitOfMeasureQty = {"_p_FIX__DerivativePriceUnitOfMeasureQty", "FIX::DerivativePriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeProduct = {"_p_FIX__DerivativeProduct", "FIX::DerivativeProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeProductComplex = {"_p_FIX__DerivativeProductComplex", "FIX::DerivativeProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePutOrCall = {"_p_FIX__DerivativePutOrCall", "FIX::DerivativePutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityAltID = {"_p_FIX__DerivativeSecurityAltID", "FIX::DerivativeSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityAltIDSource = {"_p_FIX__DerivativeSecurityAltIDSource", "FIX::DerivativeSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityDesc = {"_p_FIX__DerivativeSecurityDesc", "FIX::DerivativeSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityExchange = {"_p_FIX__DerivativeSecurityExchange", "FIX::DerivativeSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityGroup = {"_p_FIX__DerivativeSecurityGroup", "FIX::DerivativeSecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityID = {"_p_FIX__DerivativeSecurityID", "FIX::DerivativeSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityIDSource = {"_p_FIX__DerivativeSecurityIDSource", "FIX::DerivativeSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityListRequestType = {"_p_FIX__DerivativeSecurityListRequestType", "FIX::DerivativeSecurityListRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityStatus = {"_p_FIX__DerivativeSecurityStatus", "FIX::DerivativeSecurityStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecuritySubType = {"_p_FIX__DerivativeSecuritySubType", "FIX::DerivativeSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityType = {"_p_FIX__DerivativeSecurityType", "FIX::DerivativeSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXML = {"_p_FIX__DerivativeSecurityXML", "FIX::DerivativeSecurityXML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXMLLen = {"_p_FIX__DerivativeSecurityXMLLen", "FIX::DerivativeSecurityXMLLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXMLSchema = {"_p_FIX__DerivativeSecurityXMLSchema", "FIX::DerivativeSecurityXMLSchema *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSettlMethod = {"_p_FIX__DerivativeSettlMethod", "FIX::DerivativeSettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSettleOnOpenFlag = {"_p_FIX__DerivativeSettleOnOpenFlag", "FIX::DerivativeSettleOnOpenFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStateOrProvinceOfIssue = {"_p_FIX__DerivativeStateOrProvinceOfIssue", "FIX::DerivativeStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeCurrency = {"_p_FIX__DerivativeStrikeCurrency", "FIX::DerivativeStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeMultiplier = {"_p_FIX__DerivativeStrikeMultiplier", "FIX::DerivativeStrikeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikePrice = {"_p_FIX__DerivativeStrikePrice", "FIX::DerivativeStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeValue = {"_p_FIX__DerivativeStrikeValue", "FIX::DerivativeStrikeValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSymbol = {"_p_FIX__DerivativeSymbol", "FIX::DerivativeSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSymbolSfx = {"_p_FIX__DerivativeSymbolSfx", "FIX::DerivativeSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeTimeUnit = {"_p_FIX__DerivativeTimeUnit", "FIX::DerivativeTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeUnitOfMeasure = {"_p_FIX__DerivativeUnitOfMeasure", "FIX::DerivativeUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeUnitOfMeasureQty = {"_p_FIX__DerivativeUnitOfMeasureQty", "FIX::DerivativeUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeValuationMethod = {"_p_FIX__DerivativeValuationMethod", "FIX::DerivativeValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Designation = {"_p_FIX__Designation", "FIX::Designation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskID = {"_p_FIX__DeskID", "FIX::DeskID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskOrderHandlingInst = {"_p_FIX__DeskOrderHandlingInst", "FIX::DeskOrderHandlingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskType = {"_p_FIX__DeskType", "FIX::DeskType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskTypeSource = {"_p_FIX__DeskTypeSource", "FIX::DeskTypeSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DetachmentPoint = {"_p_FIX__DetachmentPoint", "FIX::DetachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Dictionary = {"_p_FIX__Dictionary", "FIX::Dictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Dictionary__Data__const_iterator = {"_p_FIX__Dictionary__Data__const_iterator", "FIX::Dictionary::Data::const_iterator *|FIX::Dictionary::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionInst = {"_p_FIX__DiscretionInst", "FIX::DiscretionInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionLimitType = {"_p_FIX__DiscretionLimitType", "FIX::DiscretionLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionMoveType = {"_p_FIX__DiscretionMoveType", "FIX::DiscretionMoveType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffset = {"_p_FIX__DiscretionOffset", "FIX::DiscretionOffset *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffsetType = {"_p_FIX__DiscretionOffsetType", "FIX::DiscretionOffsetType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffsetValue = {"_p_FIX__DiscretionOffsetValue", "FIX::DiscretionOffsetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionPrice = {"_p_FIX__DiscretionPrice", "FIX::DiscretionPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionRoundDirection = {"_p_FIX__DiscretionRoundDirection", "FIX::DiscretionRoundDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionScope = {"_p_FIX__DiscretionScope", "FIX::DiscretionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayHighQty = {"_p_FIX__DisplayHighQty", "FIX::DisplayHighQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayLowQty = {"_p_FIX__DisplayLowQty", "FIX::DisplayLowQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayMethod = {"_p_FIX__DisplayMethod", "FIX::DisplayMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayMinIncr = {"_p_FIX__DisplayMinIncr", "FIX::DisplayMinIncr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayQty = {"_p_FIX__DisplayQty", "FIX::DisplayQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayWhen = {"_p_FIX__DisplayWhen", "FIX::DisplayWhen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DistribPaymentMethod = {"_p_FIX__DistribPaymentMethod", "FIX::DistribPaymentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DistribPercentage = {"_p_FIX__DistribPercentage", "FIX::DistribPercentage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DividendYield = {"_p_FIX__DividendYield", "FIX::DividendYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DlvyInst = {"_p_FIX__DlvyInst", "FIX::DlvyInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DlvyInstType = {"_p_FIX__DlvyInstType", "FIX::DlvyInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DoNotSend = {"_p_FIX__DoNotSend", "FIX::DoNotSend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DoubleField = {"_p_FIX__DoubleField", "FIX::DoubleField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DueToRelated = {"_p_FIX__DueToRelated", "FIX::DueToRelated *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DuplicateFieldNumber = {"_p_FIX__DuplicateFieldNumber", "FIX::DuplicateFieldNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EFPTrackingError = {"_p_FIX__EFPTrackingError", "FIX::EFPTrackingError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EXCHANGE = {"_p_FIX__EXCHANGE", "FIX::EXCHANGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EffectiveTime = {"_p_FIX__EffectiveTime", "FIX::EffectiveTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EmailThreadID = {"_p_FIX__EmailThreadID", "FIX::EmailThreadID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EmailType = {"_p_FIX__EmailType", "FIX::EmailType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedAllocText = {"_p_FIX__EncodedAllocText", "FIX::EncodedAllocText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedAllocTextLen = {"_p_FIX__EncodedAllocTextLen", "FIX::EncodedAllocTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedHeadline = {"_p_FIX__EncodedHeadline", "FIX::EncodedHeadline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedHeadlineLen = {"_p_FIX__EncodedHeadlineLen", "FIX::EncodedHeadlineLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedIssuer = {"_p_FIX__EncodedIssuer", "FIX::EncodedIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedIssuerLen = {"_p_FIX__EncodedIssuerLen", "FIX::EncodedIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegIssuer = {"_p_FIX__EncodedLegIssuer", "FIX::EncodedLegIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegIssuerLen = {"_p_FIX__EncodedLegIssuerLen", "FIX::EncodedLegIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegSecurityDesc = {"_p_FIX__EncodedLegSecurityDesc", "FIX::EncodedLegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegSecurityDescLen = {"_p_FIX__EncodedLegSecurityDescLen", "FIX::EncodedLegSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListExecInst = {"_p_FIX__EncodedListExecInst", "FIX::EncodedListExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListExecInstLen = {"_p_FIX__EncodedListExecInstLen", "FIX::EncodedListExecInstLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListStatusText = {"_p_FIX__EncodedListStatusText", "FIX::EncodedListStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListStatusTextLen = {"_p_FIX__EncodedListStatusTextLen", "FIX::EncodedListStatusTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedMktSegmDesc = {"_p_FIX__EncodedMktSegmDesc", "FIX::EncodedMktSegmDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedMktSegmDescLen = {"_p_FIX__EncodedMktSegmDescLen", "FIX::EncodedMktSegmDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityDesc = {"_p_FIX__EncodedSecurityDesc", "FIX::EncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityDescLen = {"_p_FIX__EncodedSecurityDescLen", "FIX::EncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityListDesc = {"_p_FIX__EncodedSecurityListDesc", "FIX::EncodedSecurityListDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityListDescLen = {"_p_FIX__EncodedSecurityListDescLen", "FIX::EncodedSecurityListDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSubject = {"_p_FIX__EncodedSubject", "FIX::EncodedSubject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSubjectLen = {"_p_FIX__EncodedSubjectLen", "FIX::EncodedSubjectLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSymbol = {"_p_FIX__EncodedSymbol", "FIX::EncodedSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSymbolLen = {"_p_FIX__EncodedSymbolLen", "FIX::EncodedSymbolLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedText = {"_p_FIX__EncodedText", "FIX::EncodedText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedTextLen = {"_p_FIX__EncodedTextLen", "FIX::EncodedTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingIssuer = {"_p_FIX__EncodedUnderlyingIssuer", "FIX::EncodedUnderlyingIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingIssuerLen = {"_p_FIX__EncodedUnderlyingIssuerLen", "FIX::EncodedUnderlyingIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingSecurityDesc = {"_p_FIX__EncodedUnderlyingSecurityDesc", "FIX::EncodedUnderlyingSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingSecurityDescLen = {"_p_FIX__EncodedUnderlyingSecurityDescLen", "FIX::EncodedUnderlyingSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptMethod = {"_p_FIX__EncryptMethod", "FIX::EncryptMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedNewPassword = {"_p_FIX__EncryptedNewPassword", "FIX::EncryptedNewPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedNewPasswordLen = {"_p_FIX__EncryptedNewPasswordLen", "FIX::EncryptedNewPasswordLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPassword = {"_p_FIX__EncryptedPassword", "FIX::EncryptedPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPasswordLen = {"_p_FIX__EncryptedPasswordLen", "FIX::EncryptedPasswordLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPasswordMethod = {"_p_FIX__EncryptedPasswordMethod", "FIX::EncryptedPasswordMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndAccruedInterestAmt = {"_p_FIX__EndAccruedInterestAmt", "FIX::EndAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndCash = {"_p_FIX__EndCash", "FIX::EndCash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndDate = {"_p_FIX__EndDate", "FIX::EndDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndMaturityMonthYear = {"_p_FIX__EndMaturityMonthYear", "FIX::EndMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndSeqNo = {"_p_FIX__EndSeqNo", "FIX::EndSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndStrikePxRange = {"_p_FIX__EndStrikePxRange", "FIX::EndStrikePxRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndTickPriceRange = {"_p_FIX__EndTickPriceRange", "FIX::EndTickPriceRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventDate = {"_p_FIX__EventDate", "FIX::EventDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventPx = {"_p_FIX__EventPx", "FIX::EventPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventText = {"_p_FIX__EventText", "FIX::EventText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventTime = {"_p_FIX__EventTime", "FIX::EventTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventType = {"_p_FIX__EventType", "FIX::EventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDate = {"_p_FIX__ExDate", "FIX::ExDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDestination = {"_p_FIX__ExDestination", "FIX::ExDestination *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDestinationIDSource = {"_p_FIX__ExDestinationIDSource", "FIX::ExDestinationIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Exception = {"_p_FIX__Exception", "FIX::Exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeForPhysical = {"_p_FIX__ExchangeForPhysical", "FIX::ExchangeForPhysical *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeRule = {"_p_FIX__ExchangeRule", "FIX::ExchangeRule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeSpecialInstructions = {"_p_FIX__ExchangeSpecialInstructions", "FIX::ExchangeSpecialInstructions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecAckStatus = {"_p_FIX__ExecAckStatus", "FIX::ExecAckStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecBroker = {"_p_FIX__ExecBroker", "FIX::ExecBroker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecID = {"_p_FIX__ExecID", "FIX::ExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecInst = {"_p_FIX__ExecInst", "FIX::ExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecInstValue = {"_p_FIX__ExecInstValue", "FIX::ExecInstValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecPriceAdjustment = {"_p_FIX__ExecPriceAdjustment", "FIX::ExecPriceAdjustment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecPriceType = {"_p_FIX__ExecPriceType", "FIX::ExecPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecRefID = {"_p_FIX__ExecRefID", "FIX::ExecRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecRestatementReason = {"_p_FIX__ExecRestatementReason", "FIX::ExecRestatementReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecTransType = {"_p_FIX__ExecTransType", "FIX::ExecTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecType = {"_p_FIX__ExecType", "FIX::ExecType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecValuationPoint = {"_p_FIX__ExecValuationPoint", "FIX::ExecValuationPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExerciseMethod = {"_p_FIX__ExerciseMethod", "FIX::ExerciseMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExerciseStyle = {"_p_FIX__ExerciseStyle", "FIX::ExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpQty = {"_p_FIX__ExpQty", "FIX::ExpQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpType = {"_p_FIX__ExpType", "FIX::ExpType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpirationCycle = {"_p_FIX__ExpirationCycle", "FIX::ExpirationCycle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpirationQtyType = {"_p_FIX__ExpirationQtyType", "FIX::ExpirationQtyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpireDate = {"_p_FIX__ExpireDate", "FIX::ExpireDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpireTime = {"_p_FIX__ExpireTime", "FIX::ExpireTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FLOAT = {"_p_FIX__FLOAT", "FIX::FLOAT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Factor = {"_p_FIX__Factor", "FIX::Factor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FairValue = {"_p_FIX__FairValue", "FIX::FairValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FeeMultiplier = {"_p_FIX__FeeMultiplier", "FIX::FeeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldBase = {"_p_FIX__FieldBase", "FIX::FieldBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldConvertError = {"_p_FIX__FieldConvertError", "FIX::FieldConvertError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap = {"_p_FIX__FieldMap", "FIX::FieldMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap__Fields__const_iterator = {"_p_FIX__FieldMap__Fields__const_iterator", "FIX::FieldMap::Fields::const_iterator *|FIX::FieldMap::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap__Groups__const_iterator = {"_p_FIX__FieldMap__Groups__const_iterator", "FIX::FieldMap::Groups::const_iterator *|FIX::FieldMap::g_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldNotFound = {"_p_FIX__FieldNotFound", "FIX::FieldNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileLog = {"_p_FIX__FileLog", "FIX::FileLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileLogFactory = {"_p_FIX__FileLogFactory", "FIX::FileLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileStore = {"_p_FIX__FileStore", "FIX::FileStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileStoreFactory = {"_p_FIX__FileStoreFactory", "FIX::FileStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillExecID = {"_p_FIX__FillExecID", "FIX::FillExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillLiquidityInd = {"_p_FIX__FillLiquidityInd", "FIX::FillLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillPx = {"_p_FIX__FillPx", "FIX::FillPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillQty = {"_p_FIX__FillQty", "FIX::FillQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FinancialStatus = {"_p_FIX__FinancialStatus", "FIX::FinancialStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FirmTradeID = {"_p_FIX__FirmTradeID", "FIX::FirmTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FirstPx = {"_p_FIX__FirstPx", "FIX::FirstPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlexProductEligibilityIndicator = {"_p_FIX__FlexProductEligibilityIndicator", "FIX::FlexProductEligibilityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlexibleIndicator = {"_p_FIX__FlexibleIndicator", "FIX::FlexibleIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FloorPrice = {"_p_FIX__FloorPrice", "FIX::FloorPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlowScheduleType = {"_p_FIX__FlowScheduleType", "FIX::FlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ForexReq = {"_p_FIX__ForexReq", "FIX::ForexReq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FundRenewWaiv = {"_p_FIX__FundRenewWaiv", "FIX::FundRenewWaiv *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FutSettDate = {"_p_FIX__FutSettDate", "FIX::FutSettDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FutSettDate2 = {"_p_FIX__FutSettDate2", "FIX::FutSettDate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FuturesValuationMethod = {"_p_FIX__FuturesValuationMethod", "FIX::FuturesValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GTBookingInst = {"_p_FIX__GTBookingInst", "FIX::GTBookingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GapFillFlag = {"_p_FIX__GapFillFlag", "FIX::GapFillFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GrossTradeAmt = {"_p_FIX__GrossTradeAmt", "FIX::GrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Group = {"_p_FIX__Group", "FIX::Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HaltReasonChar = {"_p_FIX__HaltReasonChar", "FIX::HaltReasonChar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HaltReasonInt = {"_p_FIX__HaltReasonInt", "FIX::HaltReasonInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HandlInst = {"_p_FIX__HandlInst", "FIX::HandlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Headline = {"_p_FIX__Headline", "FIX::Headline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HeartBtInt = {"_p_FIX__HeartBtInt", "FIX::HeartBtInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HighLimitPrice = {"_p_FIX__HighLimitPrice", "FIX::HighLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HighPx = {"_p_FIX__HighPx", "FIX::HighPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopCompID = {"_p_FIX__HopCompID", "FIX::HopCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopRefID = {"_p_FIX__HopRefID", "FIX::HopRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopSendingTime = {"_p_FIX__HopSendingTime", "FIX::HopSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HostCrossID = {"_p_FIX__HostCrossID", "FIX::HostCrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IDSource = {"_p_FIX__IDSource", "FIX::IDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__INT = {"_p_FIX__INT", "FIX::INT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOException = {"_p_FIX__IOException", "FIX::IOException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIID = {"_p_FIX__IOIID", "FIX::IOIID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOINaturalFlag = {"_p_FIX__IOINaturalFlag", "FIX::IOINaturalFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIOthSvc = {"_p_FIX__IOIOthSvc", "FIX::IOIOthSvc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQltyInd = {"_p_FIX__IOIQltyInd", "FIX::IOIQltyInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQty = {"_p_FIX__IOIQty", "FIX::IOIQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQualifier = {"_p_FIX__IOIQualifier", "FIX::IOIQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIRefID = {"_p_FIX__IOIRefID", "FIX::IOIRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIShares = {"_p_FIX__IOIShares", "FIX::IOIShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOITransType = {"_p_FIX__IOITransType", "FIX::IOITransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIid = {"_p_FIX__IOIid", "FIX::IOIid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ImpliedMarketIndicator = {"_p_FIX__ImpliedMarketIndicator", "FIX::ImpliedMarketIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InViewOfCommon = {"_p_FIX__InViewOfCommon", "FIX::InViewOfCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncTaxInd = {"_p_FIX__IncTaxInd", "FIX::IncTaxInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectDataFormat = {"_p_FIX__IncorrectDataFormat", "FIX::IncorrectDataFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectMessageStructure = {"_p_FIX__IncorrectMessageStructure", "FIX::IncorrectMessageStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectTagValue = {"_p_FIX__IncorrectTagValue", "FIX::IncorrectTagValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocID = {"_p_FIX__IndividualAllocID", "FIX::IndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocRejCode = {"_p_FIX__IndividualAllocRejCode", "FIX::IndividualAllocRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocType = {"_p_FIX__IndividualAllocType", "FIX::IndividualAllocType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Initiator = {"_p_FIX__Initiator", "FIX::Initiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InputSource = {"_p_FIX__InputSource", "FIX::InputSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrAttribType = {"_p_FIX__InstrAttribType", "FIX::InstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrAttribValue = {"_p_FIX__InstrAttribValue", "FIX::InstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrRegistry = {"_p_FIX__InstrRegistry", "FIX::InstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrmtAssignmentMethod = {"_p_FIX__InstrmtAssignmentMethod", "FIX::InstrmtAssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyID = {"_p_FIX__InstrumentPartyID", "FIX::InstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyIDSource = {"_p_FIX__InstrumentPartyIDSource", "FIX::InstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyRole = {"_p_FIX__InstrumentPartyRole", "FIX::InstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartySubID = {"_p_FIX__InstrumentPartySubID", "FIX::InstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartySubIDType = {"_p_FIX__InstrumentPartySubIDType", "FIX::InstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IntField = {"_p_FIX__IntField", "FIX::IntField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InterestAccrualDate = {"_p_FIX__InterestAccrualDate", "FIX::InterestAccrualDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InterestAtMaturity = {"_p_FIX__InterestAtMaturity", "FIX::InterestAtMaturity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidMessage = {"_p_FIX__InvalidMessage", "FIX::InvalidMessage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidMessageType = {"_p_FIX__InvalidMessageType", "FIX::InvalidMessageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidTagNumber = {"_p_FIX__InvalidTagNumber", "FIX::InvalidTagNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvestorCountryOfResidence = {"_p_FIX__InvestorCountryOfResidence", "FIX::InvestorCountryOfResidence *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IssueDate = {"_p_FIX__IssueDate", "FIX::IssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Issuer = {"_p_FIX__Issuer", "FIX::Issuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LANGUAGE = {"_p_FIX__LANGUAGE", "FIX::LANGUAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LENGTH = {"_p_FIX__LENGTH", "FIX::LENGTH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LOCALMKTDATE = {"_p_FIX__LOCALMKTDATE", "FIX::LOCALMKTDATE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LanguageCode = {"_p_FIX__LanguageCode", "FIX::LanguageCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastCapacity = {"_p_FIX__LastCapacity", "FIX::LastCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastForwardPoints = {"_p_FIX__LastForwardPoints", "FIX::LastForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastForwardPoints2 = {"_p_FIX__LastForwardPoints2", "FIX::LastForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastFragment = {"_p_FIX__LastFragment", "FIX::LastFragment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastLiquidityInd = {"_p_FIX__LastLiquidityInd", "FIX::LastLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastMkt = {"_p_FIX__LastMkt", "FIX::LastMkt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastMsgSeqNumProcessed = {"_p_FIX__LastMsgSeqNumProcessed", "FIX::LastMsgSeqNumProcessed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastNetworkResponseID = {"_p_FIX__LastNetworkResponseID", "FIX::LastNetworkResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastParPx = {"_p_FIX__LastParPx", "FIX::LastParPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastPx = {"_p_FIX__LastPx", "FIX::LastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastQty = {"_p_FIX__LastQty", "FIX::LastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastRptRequested = {"_p_FIX__LastRptRequested", "FIX::LastRptRequested *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastShares = {"_p_FIX__LastShares", "FIX::LastShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastSpotRate = {"_p_FIX__LastSpotRate", "FIX::LastSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastSwapPoints = {"_p_FIX__LastSwapPoints", "FIX::LastSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastUpdateTime = {"_p_FIX__LastUpdateTime", "FIX::LastUpdateTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LateIndicator = {"_p_FIX__LateIndicator", "FIX::LateIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LeavesQty = {"_p_FIX__LeavesQty", "FIX::LeavesQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocAccount = {"_p_FIX__LegAllocAccount", "FIX::LegAllocAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocAcctIDSource = {"_p_FIX__LegAllocAcctIDSource", "FIX::LegAllocAcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocID = {"_p_FIX__LegAllocID", "FIX::LegAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocQty = {"_p_FIX__LegAllocQty", "FIX::LegAllocQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocSettlCurrency = {"_p_FIX__LegAllocSettlCurrency", "FIX::LegAllocSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurveCurrency = {"_p_FIX__LegBenchmarkCurveCurrency", "FIX::LegBenchmarkCurveCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurveName = {"_p_FIX__LegBenchmarkCurveName", "FIX::LegBenchmarkCurveName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurvePoint = {"_p_FIX__LegBenchmarkCurvePoint", "FIX::LegBenchmarkCurvePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkPrice = {"_p_FIX__LegBenchmarkPrice", "FIX::LegBenchmarkPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkPriceType = {"_p_FIX__LegBenchmarkPriceType", "FIX::LegBenchmarkPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBidForwardPoints = {"_p_FIX__LegBidForwardPoints", "FIX::LegBidForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBidPx = {"_p_FIX__LegBidPx", "FIX::LegBidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCFICode = {"_p_FIX__LegCFICode", "FIX::LegCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCalculatedCcyLastQty = {"_p_FIX__LegCalculatedCcyLastQty", "FIX::LegCalculatedCcyLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractMultiplier = {"_p_FIX__LegContractMultiplier", "FIX::LegContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractMultiplierUnit = {"_p_FIX__LegContractMultiplierUnit", "FIX::LegContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractSettlMonth = {"_p_FIX__LegContractSettlMonth", "FIX::LegContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCountryOfIssue = {"_p_FIX__LegCountryOfIssue", "FIX::LegCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCouponPaymentDate = {"_p_FIX__LegCouponPaymentDate", "FIX::LegCouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCouponRate = {"_p_FIX__LegCouponRate", "FIX::LegCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCoveredOrUncovered = {"_p_FIX__LegCoveredOrUncovered", "FIX::LegCoveredOrUncovered *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCreditRating = {"_p_FIX__LegCreditRating", "FIX::LegCreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCurrency = {"_p_FIX__LegCurrency", "FIX::LegCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCurrencyRatio = {"_p_FIX__LegCurrencyRatio", "FIX::LegCurrencyRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegDatedDate = {"_p_FIX__LegDatedDate", "FIX::LegDatedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegDividendYield = {"_p_FIX__LegDividendYield", "FIX::LegDividendYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegExecInst = {"_p_FIX__LegExecInst", "FIX::LegExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegExerciseStyle = {"_p_FIX__LegExerciseStyle", "FIX::LegExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFactor = {"_p_FIX__LegFactor", "FIX::LegFactor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFlowScheduleType = {"_p_FIX__LegFlowScheduleType", "FIX::LegFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFutSettDate = {"_p_FIX__LegFutSettDate", "FIX::LegFutSettDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegGrossTradeAmt = {"_p_FIX__LegGrossTradeAmt", "FIX::LegGrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIOIQty = {"_p_FIX__LegIOIQty", "FIX::LegIOIQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIndividualAllocID = {"_p_FIX__LegIndividualAllocID", "FIX::LegIndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegInstrRegistry = {"_p_FIX__LegInstrRegistry", "FIX::LegInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegInterestAccrualDate = {"_p_FIX__LegInterestAccrualDate", "FIX::LegInterestAccrualDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIssueDate = {"_p_FIX__LegIssueDate", "FIX::LegIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIssuer = {"_p_FIX__LegIssuer", "FIX::LegIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastForwardPoints = {"_p_FIX__LegLastForwardPoints", "FIX::LegLastForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastPx = {"_p_FIX__LegLastPx", "FIX::LegLastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastQty = {"_p_FIX__LegLastQty", "FIX::LegLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLocaleOfIssue = {"_p_FIX__LegLocaleOfIssue", "FIX::LegLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityDate = {"_p_FIX__LegMaturityDate", "FIX::LegMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityMonthYear = {"_p_FIX__LegMaturityMonthYear", "FIX::LegMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityTime = {"_p_FIX__LegMaturityTime", "FIX::LegMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegNumber = {"_p_FIX__LegNumber", "FIX::LegNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOfferForwardPoints = {"_p_FIX__LegOfferForwardPoints", "FIX::LegOfferForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOfferPx = {"_p_FIX__LegOfferPx", "FIX::LegOfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOptAttribute = {"_p_FIX__LegOptAttribute", "FIX::LegOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOptionRatio = {"_p_FIX__LegOptionRatio", "FIX::LegOptionRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOrderQty = {"_p_FIX__LegOrderQty", "FIX::LegOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPool = {"_p_FIX__LegPool", "FIX::LegPool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPositionEffect = {"_p_FIX__LegPositionEffect", "FIX::LegPositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPrice = {"_p_FIX__LegPrice", "FIX::LegPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceType = {"_p_FIX__LegPriceType", "FIX::LegPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceUnitOfMeasure = {"_p_FIX__LegPriceUnitOfMeasure", "FIX::LegPriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceUnitOfMeasureQty = {"_p_FIX__LegPriceUnitOfMeasureQty", "FIX::LegPriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegProduct = {"_p_FIX__LegProduct", "FIX::LegProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPutOrCall = {"_p_FIX__LegPutOrCall", "FIX::LegPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegQty = {"_p_FIX__LegQty", "FIX::LegQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRatioQty = {"_p_FIX__LegRatioQty", "FIX::LegRatioQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRedemptionDate = {"_p_FIX__LegRedemptionDate", "FIX::LegRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRefID = {"_p_FIX__LegRefID", "FIX::LegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepoCollateralSecurityType = {"_p_FIX__LegRepoCollateralSecurityType", "FIX::LegRepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegReportID = {"_p_FIX__LegReportID", "FIX::LegReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepurchaseRate = {"_p_FIX__LegRepurchaseRate", "FIX::LegRepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepurchaseTerm = {"_p_FIX__LegRepurchaseTerm", "FIX::LegRepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityAltID = {"_p_FIX__LegSecurityAltID", "FIX::LegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityAltIDSource = {"_p_FIX__LegSecurityAltIDSource", "FIX::LegSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityDesc = {"_p_FIX__LegSecurityDesc", "FIX::LegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityExchange = {"_p_FIX__LegSecurityExchange", "FIX::LegSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityID = {"_p_FIX__LegSecurityID", "FIX::LegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityIDSource = {"_p_FIX__LegSecurityIDSource", "FIX::LegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecuritySubType = {"_p_FIX__LegSecuritySubType", "FIX::LegSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityType = {"_p_FIX__LegSecurityType", "FIX::LegSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlCurrency = {"_p_FIX__LegSettlCurrency", "FIX::LegSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlDate = {"_p_FIX__LegSettlDate", "FIX::LegSettlDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlType = {"_p_FIX__LegSettlType", "FIX::LegSettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlmntTyp = {"_p_FIX__LegSettlmntTyp", "FIX::LegSettlmntTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSide = {"_p_FIX__LegSide", "FIX::LegSide *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStateOrProvinceOfIssue = {"_p_FIX__LegStateOrProvinceOfIssue", "FIX::LegStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStipulationType = {"_p_FIX__LegStipulationType", "FIX::LegStipulationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStipulationValue = {"_p_FIX__LegStipulationValue", "FIX::LegStipulationValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStrikeCurrency = {"_p_FIX__LegStrikeCurrency", "FIX::LegStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStrikePrice = {"_p_FIX__LegStrikePrice", "FIX::LegStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSwapType = {"_p_FIX__LegSwapType", "FIX::LegSwapType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSymbol = {"_p_FIX__LegSymbol", "FIX::LegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSymbolSfx = {"_p_FIX__LegSymbolSfx", "FIX::LegSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegTimeUnit = {"_p_FIX__LegTimeUnit", "FIX::LegTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegUnitOfMeasure = {"_p_FIX__LegUnitOfMeasure", "FIX::LegUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegUnitOfMeasureQty = {"_p_FIX__LegUnitOfMeasureQty", "FIX::LegUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegVolatility = {"_p_FIX__LegVolatility", "FIX::LegVolatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegalConfirm = {"_p_FIX__LegalConfirm", "FIX::LegalConfirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LinesOfText = {"_p_FIX__LinesOfText", "FIX::LinesOfText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityIndType = {"_p_FIX__LiquidityIndType", "FIX::LiquidityIndType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityNumSecurities = {"_p_FIX__LiquidityNumSecurities", "FIX::LiquidityNumSecurities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityPctHigh = {"_p_FIX__LiquidityPctHigh", "FIX::LiquidityPctHigh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityPctLow = {"_p_FIX__LiquidityPctLow", "FIX::LiquidityPctLow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityValue = {"_p_FIX__LiquidityValue", "FIX::LiquidityValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListExecInst = {"_p_FIX__ListExecInst", "FIX::ListExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListExecInstType = {"_p_FIX__ListExecInstType", "FIX::ListExecInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListID = {"_p_FIX__ListID", "FIX::ListID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListMethod = {"_p_FIX__ListMethod", "FIX::ListMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListName = {"_p_FIX__ListName", "FIX::ListName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListNoOrds = {"_p_FIX__ListNoOrds", "FIX::ListNoOrds *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListOrderStatus = {"_p_FIX__ListOrderStatus", "FIX::ListOrderStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListRejectReason = {"_p_FIX__ListRejectReason", "FIX::ListRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListSeqNo = {"_p_FIX__ListSeqNo", "FIX::ListSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListStatusText = {"_p_FIX__ListStatusText", "FIX::ListStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListStatusType = {"_p_FIX__ListStatusType", "FIX::ListStatusType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListUpdateAction = {"_p_FIX__ListUpdateAction", "FIX::ListUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocaleOfIssue = {"_p_FIX__LocaleOfIssue", "FIX::LocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocateReqd = {"_p_FIX__LocateReqd", "FIX::LocateReqd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocationID = {"_p_FIX__LocationID", "FIX::LocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Log = {"_p_FIX__Log", "FIX::Log *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LogFactory = {"_p_FIX__LogFactory", "FIX::LogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LongQty = {"_p_FIX__LongQty", "FIX::LongQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LotType = {"_p_FIX__LotType", "FIX::LotType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LowLimitPrice = {"_p_FIX__LowLimitPrice", "FIX::LowLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LowPx = {"_p_FIX__LowPx", "FIX::LowPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDBookType = {"_p_FIX__MDBookType", "FIX::MDBookType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryBuyer = {"_p_FIX__MDEntryBuyer", "FIX::MDEntryBuyer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryDate = {"_p_FIX__MDEntryDate", "FIX::MDEntryDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryForwardPoints = {"_p_FIX__MDEntryForwardPoints", "FIX::MDEntryForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryID = {"_p_FIX__MDEntryID", "FIX::MDEntryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryOriginator = {"_p_FIX__MDEntryOriginator", "FIX::MDEntryOriginator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryPositionNo = {"_p_FIX__MDEntryPositionNo", "FIX::MDEntryPositionNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryPx = {"_p_FIX__MDEntryPx", "FIX::MDEntryPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryRefID = {"_p_FIX__MDEntryRefID", "FIX::MDEntryRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySeller = {"_p_FIX__MDEntrySeller", "FIX::MDEntrySeller *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySize = {"_p_FIX__MDEntrySize", "FIX::MDEntrySize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySpotRate = {"_p_FIX__MDEntrySpotRate", "FIX::MDEntrySpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryTime = {"_p_FIX__MDEntryTime", "FIX::MDEntryTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryType = {"_p_FIX__MDEntryType", "FIX::MDEntryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDFeedType = {"_p_FIX__MDFeedType", "FIX::MDFeedType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDImplicitDelete = {"_p_FIX__MDImplicitDelete", "FIX::MDImplicitDelete *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDMkt = {"_p_FIX__MDMkt", "FIX::MDMkt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDOriginType = {"_p_FIX__MDOriginType", "FIX::MDOriginType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDPriceLevel = {"_p_FIX__MDPriceLevel", "FIX::MDPriceLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDQuoteType = {"_p_FIX__MDQuoteType", "FIX::MDQuoteType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReportID = {"_p_FIX__MDReportID", "FIX::MDReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReqID = {"_p_FIX__MDReqID", "FIX::MDReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReqRejReason = {"_p_FIX__MDReqRejReason", "FIX::MDReqRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSecSize = {"_p_FIX__MDSecSize", "FIX::MDSecSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSecSizeType = {"_p_FIX__MDSecSizeType", "FIX::MDSecSizeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDStreamID = {"_p_FIX__MDStreamID", "FIX::MDStreamID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSubBookType = {"_p_FIX__MDSubBookType", "FIX::MDSubBookType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDUpdateAction = {"_p_FIX__MDUpdateAction", "FIX::MDUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDUpdateType = {"_p_FIX__MDUpdateType", "FIX::MDUpdateType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MONTHYEAR = {"_p_FIX__MONTHYEAR", "FIX::MONTHYEAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLECHARVALUE = {"_p_FIX__MULTIPLECHARVALUE", "FIX::MULTIPLECHARVALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLESTRINGVALUE = {"_p_FIX__MULTIPLESTRINGVALUE", "FIX::MULTIPLESTRINGVALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLEVALUESTRING = {"_p_FIX__MULTIPLEVALUESTRING", "FIX::MULTIPLEVALUESTRING *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MailingDtls = {"_p_FIX__MailingDtls", "FIX::MailingDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MailingInst = {"_p_FIX__MailingInst", "FIX::MailingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ManualOrderIndicator = {"_p_FIX__ManualOrderIndicator", "FIX::ManualOrderIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarginExcess = {"_p_FIX__MarginExcess", "FIX::MarginExcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarginRatio = {"_p_FIX__MarginRatio", "FIX::MarginRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketDepth = {"_p_FIX__MarketDepth", "FIX::MarketDepth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketID = {"_p_FIX__MarketID", "FIX::MarketID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketReportID = {"_p_FIX__MarketReportID", "FIX::MarketReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketReqID = {"_p_FIX__MarketReqID", "FIX::MarketReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketSegmentDesc = {"_p_FIX__MarketSegmentDesc", "FIX::MarketSegmentDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketSegmentID = {"_p_FIX__MarketSegmentID", "FIX::MarketSegmentID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketUpdateAction = {"_p_FIX__MarketUpdateAction", "FIX::MarketUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionRejectReason = {"_p_FIX__MassActionRejectReason", "FIX::MassActionRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionReportID = {"_p_FIX__MassActionReportID", "FIX::MassActionReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionResponse = {"_p_FIX__MassActionResponse", "FIX::MassActionResponse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionScope = {"_p_FIX__MassActionScope", "FIX::MassActionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionType = {"_p_FIX__MassActionType", "FIX::MassActionType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelRejectReason = {"_p_FIX__MassCancelRejectReason", "FIX::MassCancelRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelRequestType = {"_p_FIX__MassCancelRequestType", "FIX::MassCancelRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelResponse = {"_p_FIX__MassCancelResponse", "FIX::MassCancelResponse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassStatusReqID = {"_p_FIX__MassStatusReqID", "FIX::MassStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassStatusReqType = {"_p_FIX__MassStatusReqType", "FIX::MassStatusReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchAlgorithm = {"_p_FIX__MatchAlgorithm", "FIX::MatchAlgorithm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchIncrement = {"_p_FIX__MatchIncrement", "FIX::MatchIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchStatus = {"_p_FIX__MatchStatus", "FIX::MatchStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchType = {"_p_FIX__MatchType", "FIX::MatchType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityDate = {"_p_FIX__MaturityDate", "FIX::MaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityDay = {"_p_FIX__MaturityDay", "FIX::MaturityDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYear = {"_p_FIX__MaturityMonthYear", "FIX::MaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearFormat = {"_p_FIX__MaturityMonthYearFormat", "FIX::MaturityMonthYearFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearIncrement = {"_p_FIX__MaturityMonthYearIncrement", "FIX::MaturityMonthYearIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearIncrementUnits = {"_p_FIX__MaturityMonthYearIncrementUnits", "FIX::MaturityMonthYearIncrementUnits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityNetMoney = {"_p_FIX__MaturityNetMoney", "FIX::MaturityNetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityRuleID = {"_p_FIX__MaturityRuleID", "FIX::MaturityRuleID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityTime = {"_p_FIX__MaturityTime", "FIX::MaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxFloor = {"_p_FIX__MaxFloor", "FIX::MaxFloor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxMessageSize = {"_p_FIX__MaxMessageSize", "FIX::MaxMessageSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxPriceLevels = {"_p_FIX__MaxPriceLevels", "FIX::MaxPriceLevels *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxPriceVariation = {"_p_FIX__MaxPriceVariation", "FIX::MaxPriceVariation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxShow = {"_p_FIX__MaxShow", "FIX::MaxShow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxTradeVol = {"_p_FIX__MaxTradeVol", "FIX::MaxTradeVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MemoryStore = {"_p_FIX__MemoryStore", "FIX::MemoryStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MemoryStoreFactory = {"_p_FIX__MemoryStoreFactory", "FIX::MemoryStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Message = {"_p_FIX__Message", "FIX::Message *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageEncoding = {"_p_FIX__MessageEncoding", "FIX::MessageEncoding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageEventSource = {"_p_FIX__MessageEventSource", "FIX::MessageEventSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageParseError = {"_p_FIX__MessageParseError", "FIX::MessageParseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStore = {"_p_FIX__MessageStore", "FIX::MessageStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreExceptionWrapper = {"_p_FIX__MessageStoreExceptionWrapper", "FIX::MessageStoreExceptionWrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreFactory = {"_p_FIX__MessageStoreFactory", "FIX::MessageStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreFactoryExceptionWrapper = {"_p_FIX__MessageStoreFactoryExceptionWrapper", "FIX::MessageStoreFactoryExceptionWrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MidPx = {"_p_FIX__MidPx", "FIX::MidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MidYield = {"_p_FIX__MidYield", "FIX::MidYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinBidSize = {"_p_FIX__MinBidSize", "FIX::MinBidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinLotSize = {"_p_FIX__MinLotSize", "FIX::MinLotSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinOfferSize = {"_p_FIX__MinOfferSize", "FIX::MinOfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinPriceIncrement = {"_p_FIX__MinPriceIncrement", "FIX::MinPriceIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinPriceIncrementAmount = {"_p_FIX__MinPriceIncrementAmount", "FIX::MinPriceIncrementAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinQty = {"_p_FIX__MinQty", "FIX::MinQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinTradeVol = {"_p_FIX__MinTradeVol", "FIX::MinTradeVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeAmt = {"_p_FIX__MiscFeeAmt", "FIX::MiscFeeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeBasis = {"_p_FIX__MiscFeeBasis", "FIX::MiscFeeBasis *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeCurr = {"_p_FIX__MiscFeeCurr", "FIX::MiscFeeCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeType = {"_p_FIX__MiscFeeType", "FIX::MiscFeeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MktBidPx = {"_p_FIX__MktBidPx", "FIX::MktBidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MktOfferPx = {"_p_FIX__MktOfferPx", "FIX::MktOfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ModelType = {"_p_FIX__ModelType", "FIX::ModelType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MoneyLaunderingStatus = {"_p_FIX__MoneyLaunderingStatus", "FIX::MoneyLaunderingStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgDirection = {"_p_FIX__MsgDirection", "FIX::MsgDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgSeqNum = {"_p_FIX__MsgSeqNum", "FIX::MsgSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgType = {"_p_FIX__MsgType", "FIX::MsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultiLegReportingType = {"_p_FIX__MultiLegReportingType", "FIX::MultiLegReportingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultiLegRptTypeReq = {"_p_FIX__MultiLegRptTypeReq", "FIX::MultiLegRptTypeReq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultilegModel = {"_p_FIX__MultilegModel", "FIX::MultilegModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultilegPriceMethod = {"_p_FIX__MultilegPriceMethod", "FIX::MultilegPriceMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NTPositionLimit = {"_p_FIX__NTPositionLimit", "FIX::NTPositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NUMINGROUP = {"_p_FIX__NUMINGROUP", "FIX::NUMINGROUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyID = {"_p_FIX__Nested2PartyID", "FIX::Nested2PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyIDSource = {"_p_FIX__Nested2PartyIDSource", "FIX::Nested2PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyRole = {"_p_FIX__Nested2PartyRole", "FIX::Nested2PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartySubID = {"_p_FIX__Nested2PartySubID", "FIX::Nested2PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartySubIDType = {"_p_FIX__Nested2PartySubIDType", "FIX::Nested2PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyID = {"_p_FIX__Nested3PartyID", "FIX::Nested3PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyIDSource = {"_p_FIX__Nested3PartyIDSource", "FIX::Nested3PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyRole = {"_p_FIX__Nested3PartyRole", "FIX::Nested3PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartySubID = {"_p_FIX__Nested3PartySubID", "FIX::Nested3PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartySubIDType = {"_p_FIX__Nested3PartySubIDType", "FIX::Nested3PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyID = {"_p_FIX__Nested4PartyID", "FIX::Nested4PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyIDSource = {"_p_FIX__Nested4PartyIDSource", "FIX::Nested4PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyRole = {"_p_FIX__Nested4PartyRole", "FIX::Nested4PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartySubID = {"_p_FIX__Nested4PartySubID", "FIX::Nested4PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartySubIDType = {"_p_FIX__Nested4PartySubIDType", "FIX::Nested4PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedInstrAttribType = {"_p_FIX__NestedInstrAttribType", "FIX::NestedInstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedInstrAttribValue = {"_p_FIX__NestedInstrAttribValue", "FIX::NestedInstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyID = {"_p_FIX__NestedPartyID", "FIX::NestedPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyIDSource = {"_p_FIX__NestedPartyIDSource", "FIX::NestedPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyRole = {"_p_FIX__NestedPartyRole", "FIX::NestedPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartySubID = {"_p_FIX__NestedPartySubID", "FIX::NestedPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartySubIDType = {"_p_FIX__NestedPartySubIDType", "FIX::NestedPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetChgPrevDay = {"_p_FIX__NetChgPrevDay", "FIX::NetChgPrevDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetGrossInd = {"_p_FIX__NetGrossInd", "FIX::NetGrossInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetMoney = {"_p_FIX__NetMoney", "FIX::NetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkRequestID = {"_p_FIX__NetworkRequestID", "FIX::NetworkRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkRequestType = {"_p_FIX__NetworkRequestType", "FIX::NetworkRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkResponseID = {"_p_FIX__NetworkResponseID", "FIX::NetworkResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkStatusResponseType = {"_p_FIX__NetworkStatusResponseType", "FIX::NetworkStatusResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewPassword = {"_p_FIX__NewPassword", "FIX::NewPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewSeqNo = {"_p_FIX__NewSeqNo", "FIX::NewSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsCategory = {"_p_FIX__NewsCategory", "FIX::NewsCategory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsID = {"_p_FIX__NewsID", "FIX::NewsID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsRefID = {"_p_FIX__NewsRefID", "FIX::NewsRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsRefType = {"_p_FIX__NewsRefType", "FIX::NewsRefType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NextExpectedMsgSeqNum = {"_p_FIX__NextExpectedMsgSeqNum", "FIX::NextExpectedMsgSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAffectedOrders = {"_p_FIX__NoAffectedOrders", "FIX::NoAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAllocs = {"_p_FIX__NoAllocs", "FIX::NoAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAltMDSource = {"_p_FIX__NoAltMDSource", "FIX::NoAltMDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoApplIDs = {"_p_FIX__NoApplIDs", "FIX::NoApplIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAsgnReqs = {"_p_FIX__NoAsgnReqs", "FIX::NoAsgnReqs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoBidComponents = {"_p_FIX__NoBidComponents", "FIX::NoBidComponents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoBidDescriptors = {"_p_FIX__NoBidDescriptors", "FIX::NoBidDescriptors *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCapacities = {"_p_FIX__NoCapacities", "FIX::NoCapacities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoClearingInstructions = {"_p_FIX__NoClearingInstructions", "FIX::NoClearingInstructions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCollInquiryQualifier = {"_p_FIX__NoCollInquiryQualifier", "FIX::NoCollInquiryQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCompIDs = {"_p_FIX__NoCompIDs", "FIX::NoCompIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEventDates = {"_p_FIX__NoComplexEventDates", "FIX::NoComplexEventDates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEventTimes = {"_p_FIX__NoComplexEventTimes", "FIX::NoComplexEventTimes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEvents = {"_p_FIX__NoComplexEvents", "FIX::NoComplexEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContAmts = {"_p_FIX__NoContAmts", "FIX::NoContAmts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContextPartyIDs = {"_p_FIX__NoContextPartyIDs", "FIX::NoContextPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContextPartySubIDs = {"_p_FIX__NoContextPartySubIDs", "FIX::NoContextPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContraBrokers = {"_p_FIX__NoContraBrokers", "FIX::NoContraBrokers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDates = {"_p_FIX__NoDates", "FIX::NoDates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeEvents = {"_p_FIX__NoDerivativeEvents", "FIX::NoDerivativeEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrAttrib = {"_p_FIX__NoDerivativeInstrAttrib", "FIX::NoDerivativeInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrumentParties = {"_p_FIX__NoDerivativeInstrumentParties", "FIX::NoDerivativeInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrumentPartySubIDs = {"_p_FIX__NoDerivativeInstrumentPartySubIDs", "FIX::NoDerivativeInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeSecurityAltID = {"_p_FIX__NoDerivativeSecurityAltID", "FIX::NoDerivativeSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDistribInsts = {"_p_FIX__NoDistribInsts", "FIX::NoDistribInsts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDlvyInst = {"_p_FIX__NoDlvyInst", "FIX::NoDlvyInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoEvents = {"_p_FIX__NoEvents", "FIX::NoEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExecInstRules = {"_p_FIX__NoExecInstRules", "FIX::NoExecInstRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExecs = {"_p_FIX__NoExecs", "FIX::NoExecs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExpiration = {"_p_FIX__NoExpiration", "FIX::NoExpiration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoFills = {"_p_FIX__NoFills", "FIX::NoFills *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoHops = {"_p_FIX__NoHops", "FIX::NoHops *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoIOIQualifiers = {"_p_FIX__NoIOIQualifiers", "FIX::NoIOIQualifiers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrAttrib = {"_p_FIX__NoInstrAttrib", "FIX::NoInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrumentParties = {"_p_FIX__NoInstrumentParties", "FIX::NoInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrumentPartySubIDs = {"_p_FIX__NoInstrumentPartySubIDs", "FIX::NoInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegAllocs = {"_p_FIX__NoLegAllocs", "FIX::NoLegAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegSecurityAltID = {"_p_FIX__NoLegSecurityAltID", "FIX::NoLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegStipulations = {"_p_FIX__NoLegStipulations", "FIX::NoLegStipulations *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegs = {"_p_FIX__NoLegs", "FIX::NoLegs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLinesOfText = {"_p_FIX__NoLinesOfText", "FIX::NoLinesOfText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLotTypeRules = {"_p_FIX__NoLotTypeRules", "FIX::NoLotTypeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDEntries = {"_p_FIX__NoMDEntries", "FIX::NoMDEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDEntryTypes = {"_p_FIX__NoMDEntryTypes", "FIX::NoMDEntryTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDFeedTypes = {"_p_FIX__NoMDFeedTypes", "FIX::NoMDFeedTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMarketSegments = {"_p_FIX__NoMarketSegments", "FIX::NoMarketSegments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMatchRules = {"_p_FIX__NoMatchRules", "FIX::NoMatchRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMaturityRules = {"_p_FIX__NoMaturityRules", "FIX::NoMaturityRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMiscFees = {"_p_FIX__NoMiscFees", "FIX::NoMiscFees *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMsgTypes = {"_p_FIX__NoMsgTypes", "FIX::NoMsgTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested2PartyIDs = {"_p_FIX__NoNested2PartyIDs", "FIX::NoNested2PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested2PartySubIDs = {"_p_FIX__NoNested2PartySubIDs", "FIX::NoNested2PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested3PartyIDs = {"_p_FIX__NoNested3PartyIDs", "FIX::NoNested3PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested3PartySubIDs = {"_p_FIX__NoNested3PartySubIDs", "FIX::NoNested3PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested4PartyIDs = {"_p_FIX__NoNested4PartyIDs", "FIX::NoNested4PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested4PartySubIDs = {"_p_FIX__NoNested4PartySubIDs", "FIX::NoNested4PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedInstrAttrib = {"_p_FIX__NoNestedInstrAttrib", "FIX::NoNestedInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedPartyIDs = {"_p_FIX__NoNestedPartyIDs", "FIX::NoNestedPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedPartySubIDs = {"_p_FIX__NoNestedPartySubIDs", "FIX::NoNestedPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNewsRefIDs = {"_p_FIX__NoNewsRefIDs", "FIX::NoNewsRefIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNotAffectedOrders = {"_p_FIX__NoNotAffectedOrders", "FIX::NoNotAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOfLegUnderlyings = {"_p_FIX__NoOfLegUnderlyings", "FIX::NoOfLegUnderlyings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOfSecSizes = {"_p_FIX__NoOfSecSizes", "FIX::NoOfSecSizes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOrdTypeRules = {"_p_FIX__NoOrdTypeRules", "FIX::NoOrdTypeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOrders = {"_p_FIX__NoOrders", "FIX::NoOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyAltIDs = {"_p_FIX__NoPartyAltIDs", "FIX::NoPartyAltIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyAltSubIDs = {"_p_FIX__NoPartyAltSubIDs", "FIX::NoPartyAltSubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyIDs = {"_p_FIX__NoPartyIDs", "FIX::NoPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyList = {"_p_FIX__NoPartyList", "FIX::NoPartyList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyListResponseTypes = {"_p_FIX__NoPartyListResponseTypes", "FIX::NoPartyListResponseTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyRelationships = {"_p_FIX__NoPartyRelationships", "FIX::NoPartyRelationships *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartySubIDs = {"_p_FIX__NoPartySubIDs", "FIX::NoPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPosAmt = {"_p_FIX__NoPosAmt", "FIX::NoPosAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPositions = {"_p_FIX__NoPositions", "FIX::NoPositions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteEntries = {"_p_FIX__NoQuoteEntries", "FIX::NoQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteQualifiers = {"_p_FIX__NoQuoteQualifiers", "FIX::NoQuoteQualifiers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteSets = {"_p_FIX__NoQuoteSets", "FIX::NoQuoteSets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRateSources = {"_p_FIX__NoRateSources", "FIX::NoRateSources *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRegistDtls = {"_p_FIX__NoRegistDtls", "FIX::NoRegistDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedContextPartyIDs = {"_p_FIX__NoRelatedContextPartyIDs", "FIX::NoRelatedContextPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedContextPartySubIDs = {"_p_FIX__NoRelatedContextPartySubIDs", "FIX::NoRelatedContextPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartyAltIDs = {"_p_FIX__NoRelatedPartyAltIDs", "FIX::NoRelatedPartyAltIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartyAltSubIDs = {"_p_FIX__NoRelatedPartyAltSubIDs", "FIX::NoRelatedPartyAltSubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartyIDs = {"_p_FIX__NoRelatedPartyIDs", "FIX::NoRelatedPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedPartySubIDs = {"_p_FIX__NoRelatedPartySubIDs", "FIX::NoRelatedPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedSym = {"_p_FIX__NoRelatedSym", "FIX::NoRelatedSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelationshipRiskInstruments = {"_p_FIX__NoRelationshipRiskInstruments", "FIX::NoRelationshipRiskInstruments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelationshipRiskLimits = {"_p_FIX__NoRelationshipRiskLimits", "FIX::NoRelationshipRiskLimits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelationshipRiskSecurityAltID = {"_p_FIX__NoRelationshipRiskSecurityAltID", "FIX::NoRelationshipRiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelationshipRiskWarningLevels = {"_p_FIX__NoRelationshipRiskWarningLevels", "FIX::NoRelationshipRiskWarningLevels *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRequestedPartyRoles = {"_p_FIX__NoRequestedPartyRoles", "FIX::NoRequestedPartyRoles *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskInstruments = {"_p_FIX__NoRiskInstruments", "FIX::NoRiskInstruments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskLimits = {"_p_FIX__NoRiskLimits", "FIX::NoRiskLimits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskSecurityAltID = {"_p_FIX__NoRiskSecurityAltID", "FIX::NoRiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRiskWarningLevels = {"_p_FIX__NoRiskWarningLevels", "FIX::NoRiskWarningLevels *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRootPartyIDs = {"_p_FIX__NoRootPartyIDs", "FIX::NoRootPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRootPartySubIDs = {"_p_FIX__NoRootPartySubIDs", "FIX::NoRootPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRoutingIDs = {"_p_FIX__NoRoutingIDs", "FIX::NoRoutingIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRpts = {"_p_FIX__NoRpts", "FIX::NoRpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSecurityAltID = {"_p_FIX__NoSecurityAltID", "FIX::NoSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSecurityTypes = {"_p_FIX__NoSecurityTypes", "FIX::NoSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlDetails = {"_p_FIX__NoSettlDetails", "FIX::NoSettlDetails *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlInst = {"_p_FIX__NoSettlInst", "FIX::NoSettlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlOblig = {"_p_FIX__NoSettlOblig", "FIX::NoSettlOblig *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlPartyIDs = {"_p_FIX__NoSettlPartyIDs", "FIX::NoSettlPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlPartySubIDs = {"_p_FIX__NoSettlPartySubIDs", "FIX::NoSettlPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSideTrdRegTS = {"_p_FIX__NoSideTrdRegTS", "FIX::NoSideTrdRegTS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSides = {"_p_FIX__NoSides", "FIX::NoSides *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStatsIndicators = {"_p_FIX__NoStatsIndicators", "FIX::NoStatsIndicators *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStipulations = {"_p_FIX__NoStipulations", "FIX::NoStipulations *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrategyParameters = {"_p_FIX__NoStrategyParameters", "FIX::NoStrategyParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrikeRules = {"_p_FIX__NoStrikeRules", "FIX::NoStrikeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrikes = {"_p_FIX__NoStrikes", "FIX::NoStrikes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTagValue = {"_p_FIX__NoTagValue", "FIX::NoTagValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTargetPartyIDs = {"_p_FIX__NoTargetPartyIDs", "FIX::NoTargetPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTickRules = {"_p_FIX__NoTickRules", "FIX::NoTickRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTimeInForceRules = {"_p_FIX__NoTimeInForceRules", "FIX::NoTimeInForceRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrades = {"_p_FIX__NoTrades", "FIX::NoTrades *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTradingSessionRules = {"_p_FIX__NoTradingSessionRules", "FIX::NoTradingSessionRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTradingSessions = {"_p_FIX__NoTradingSessions", "FIX::NoTradingSessions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrdRegTimestamps = {"_p_FIX__NoTrdRegTimestamps", "FIX::NoTrdRegTimestamps *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrdRepIndicators = {"_p_FIX__NoTrdRepIndicators", "FIX::NoTrdRepIndicators *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingAmounts = {"_p_FIX__NoUnderlyingAmounts", "FIX::NoUnderlyingAmounts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingLegSecurityAltID = {"_p_FIX__NoUnderlyingLegSecurityAltID", "FIX::NoUnderlyingLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingSecurityAltID = {"_p_FIX__NoUnderlyingSecurityAltID", "FIX::NoUnderlyingSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingStips = {"_p_FIX__NoUnderlyingStips", "FIX::NoUnderlyingStips *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyings = {"_p_FIX__NoUnderlyings", "FIX::NoUnderlyings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUndlyInstrumentParties = {"_p_FIX__NoUndlyInstrumentParties", "FIX::NoUndlyInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUndlyInstrumentPartySubIDs = {"_p_FIX__NoUndlyInstrumentPartySubIDs", "FIX::NoUndlyInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotAffOrigClOrdID = {"_p_FIX__NotAffOrigClOrdID", "FIX::NotAffOrigClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotAffectedOrderID = {"_p_FIX__NotAffectedOrderID", "FIX::NotAffectedOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotifyBrokerOfCredit = {"_p_FIX__NotifyBrokerOfCredit", "FIX::NotifyBrokerOfCredit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotionalPercentageOutstanding = {"_p_FIX__NotionalPercentageOutstanding", "FIX::NotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NullApplication = {"_p_FIX__NullApplication", "FIX::NullApplication *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NullLog = {"_p_FIX__NullLog", "FIX::NullLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumBidders = {"_p_FIX__NumBidders", "FIX::NumBidders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumDaysInterest = {"_p_FIX__NumDaysInterest", "FIX::NumDaysInterest *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumTickets = {"_p_FIX__NumTickets", "FIX::NumTickets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumberOfOrders = {"_p_FIX__NumberOfOrders", "FIX::NumberOfOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OddLot = {"_p_FIX__OddLot", "FIX::OddLot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferForwardPoints = {"_p_FIX__OfferForwardPoints", "FIX::OfferForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferForwardPoints2 = {"_p_FIX__OfferForwardPoints2", "FIX::OfferForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferPx = {"_p_FIX__OfferPx", "FIX::OfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSize = {"_p_FIX__OfferSize", "FIX::OfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSpotRate = {"_p_FIX__OfferSpotRate", "FIX::OfferSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSwapPoints = {"_p_FIX__OfferSwapPoints", "FIX::OfferSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferYield = {"_p_FIX__OfferYield", "FIX::OfferYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfCompID = {"_p_FIX__OnBehalfOfCompID", "FIX::OnBehalfOfCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfLocationID = {"_p_FIX__OnBehalfOfLocationID", "FIX::OnBehalfOfLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfSendingTime = {"_p_FIX__OnBehalfOfSendingTime", "FIX::OnBehalfOfSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfSubID = {"_p_FIX__OnBehalfOfSubID", "FIX::OnBehalfOfSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenClose = {"_p_FIX__OpenClose", "FIX::OpenClose *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenCloseSettlFlag = {"_p_FIX__OpenCloseSettlFlag", "FIX::OpenCloseSettlFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenCloseSettleFlag = {"_p_FIX__OpenCloseSettleFlag", "FIX::OpenCloseSettleFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenInterest = {"_p_FIX__OpenInterest", "FIX::OpenInterest *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptAttribute = {"_p_FIX__OptAttribute", "FIX::OptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayAmount = {"_p_FIX__OptPayAmount", "FIX::OptPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayoutAmount = {"_p_FIX__OptPayoutAmount", "FIX::OptPayoutAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayoutType = {"_p_FIX__OptPayoutType", "FIX::OptPayoutType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdRejReason = {"_p_FIX__OrdRejReason", "FIX::OrdRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdStatus = {"_p_FIX__OrdStatus", "FIX::OrdStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdStatusReqID = {"_p_FIX__OrdStatusReqID", "FIX::OrdStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdType = {"_p_FIX__OrdType", "FIX::OrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderAvgPx = {"_p_FIX__OrderAvgPx", "FIX::OrderAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderBookingQty = {"_p_FIX__OrderBookingQty", "FIX::OrderBookingQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCapacity = {"_p_FIX__OrderCapacity", "FIX::OrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCapacityQty = {"_p_FIX__OrderCapacityQty", "FIX::OrderCapacityQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCategory = {"_p_FIX__OrderCategory", "FIX::OrderCategory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderDelay = {"_p_FIX__OrderDelay", "FIX::OrderDelay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderDelayUnit = {"_p_FIX__OrderDelayUnit", "FIX::OrderDelayUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderHandlingInstSource = {"_p_FIX__OrderHandlingInstSource", "FIX::OrderHandlingInstSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderID = {"_p_FIX__OrderID", "FIX::OrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderInputDevice = {"_p_FIX__OrderInputDevice", "FIX::OrderInputDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderPercent = {"_p_FIX__OrderPercent", "FIX::OrderPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderQty = {"_p_FIX__OrderQty", "FIX::OrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderQty2 = {"_p_FIX__OrderQty2", "FIX::OrderQty2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderRestrictions = {"_p_FIX__OrderRestrictions", "FIX::OrderRestrictions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigClOrdID = {"_p_FIX__OrigClOrdID", "FIX::OrigClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigCrossID = {"_p_FIX__OrigCrossID", "FIX::OrigCrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigCustOrderCapacity = {"_p_FIX__OrigCustOrderCapacity", "FIX::OrigCustOrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigOrdModTime = {"_p_FIX__OrigOrdModTime", "FIX::OrigOrdModTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigPosReqRefID = {"_p_FIX__OrigPosReqRefID", "FIX::OrigPosReqRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigSecondaryTradeID = {"_p_FIX__OrigSecondaryTradeID", "FIX::OrigSecondaryTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigSendingTime = {"_p_FIX__OrigSendingTime", "FIX::OrigSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTime = {"_p_FIX__OrigTime", "FIX::OrigTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeDate = {"_p_FIX__OrigTradeDate", "FIX::OrigTradeDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeHandlingInstr = {"_p_FIX__OrigTradeHandlingInstr", "FIX::OrigTradeHandlingInstr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeID = {"_p_FIX__OrigTradeID", "FIX::OrigTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OriginalNotionalPercentageOutstanding = {"_p_FIX__OriginalNotionalPercentageOutstanding", "FIX::OriginalNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OutMainCntryUIndex = {"_p_FIX__OutMainCntryUIndex", "FIX::OutMainCntryUIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OutsideIndexPct = {"_p_FIX__OutsideIndexPct", "FIX::OutsideIndexPct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OwnerType = {"_p_FIX__OwnerType", "FIX::OwnerType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OwnershipType = {"_p_FIX__OwnershipType", "FIX::OwnershipType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PERCENTAGE = {"_p_FIX__PERCENTAGE", "FIX::PERCENTAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PRICE = {"_p_FIX__PRICE", "FIX::PRICE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PRICEOFFSET = {"_p_FIX__PRICEOFFSET", "FIX::PRICEOFFSET *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ParentMktSegmID = {"_p_FIX__ParentMktSegmID", "FIX::ParentMktSegmID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ParticipationRate = {"_p_FIX__ParticipationRate", "FIX::ParticipationRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyAltID = {"_p_FIX__PartyAltID", "FIX::PartyAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyAltIDSource = {"_p_FIX__PartyAltIDSource", "FIX::PartyAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyAltSubID = {"_p_FIX__PartyAltSubID", "FIX::PartyAltSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyAltSubIDType = {"_p_FIX__PartyAltSubIDType", "FIX::PartyAltSubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyDetailsListReportID = {"_p_FIX__PartyDetailsListReportID", "FIX::PartyDetailsListReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyDetailsListRequestID = {"_p_FIX__PartyDetailsListRequestID", "FIX::PartyDetailsListRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyDetailsRequestResult = {"_p_FIX__PartyDetailsRequestResult", "FIX::PartyDetailsRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyID = {"_p_FIX__PartyID", "FIX::PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyIDSource = {"_p_FIX__PartyIDSource", "FIX::PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyListResponseType = {"_p_FIX__PartyListResponseType", "FIX::PartyListResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyRelationship = {"_p_FIX__PartyRelationship", "FIX::PartyRelationship *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyRole = {"_p_FIX__PartyRole", "FIX::PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartySubID = {"_p_FIX__PartySubID", "FIX::PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartySubIDType = {"_p_FIX__PartySubIDType", "FIX::PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Password = {"_p_FIX__Password", "FIX::Password *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentDate = {"_p_FIX__PaymentDate", "FIX::PaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentMethod = {"_p_FIX__PaymentMethod", "FIX::PaymentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentRef = {"_p_FIX__PaymentRef", "FIX::PaymentRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentRemitterID = {"_p_FIX__PaymentRemitterID", "FIX::PaymentRemitterID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PctAtRisk = {"_p_FIX__PctAtRisk", "FIX::PctAtRisk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegDifference = {"_p_FIX__PegDifference", "FIX::PegDifference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegLimitType = {"_p_FIX__PegLimitType", "FIX::PegLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegMoveType = {"_p_FIX__PegMoveType", "FIX::PegMoveType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegOffsetType = {"_p_FIX__PegOffsetType", "FIX::PegOffsetType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegOffsetValue = {"_p_FIX__PegOffsetValue", "FIX::PegOffsetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegPriceType = {"_p_FIX__PegPriceType", "FIX::PegPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegRoundDirection = {"_p_FIX__PegRoundDirection", "FIX::PegRoundDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegScope = {"_p_FIX__PegScope", "FIX::PegScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityDesc = {"_p_FIX__PegSecurityDesc", "FIX::PegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityID = {"_p_FIX__PegSecurityID", "FIX::PegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityIDSource = {"_p_FIX__PegSecurityIDSource", "FIX::PegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSymbol = {"_p_FIX__PegSymbol", "FIX::PegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PeggedPrice = {"_p_FIX__PeggedPrice", "FIX::PeggedPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PeggedRefPrice = {"_p_FIX__PeggedRefPrice", "FIX::PeggedRefPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Pool = {"_p_FIX__Pool", "FIX::Pool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosAmt = {"_p_FIX__PosAmt", "FIX::PosAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosAmtType = {"_p_FIX__PosAmtType", "FIX::PosAmtType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintAction = {"_p_FIX__PosMaintAction", "FIX::PosMaintAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintResult = {"_p_FIX__PosMaintResult", "FIX::PosMaintResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintRptID = {"_p_FIX__PosMaintRptID", "FIX::PosMaintRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintRptRefID = {"_p_FIX__PosMaintRptRefID", "FIX::PosMaintRptRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintStatus = {"_p_FIX__PosMaintStatus", "FIX::PosMaintStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosQtyStatus = {"_p_FIX__PosQtyStatus", "FIX::PosQtyStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqID = {"_p_FIX__PosReqID", "FIX::PosReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqResult = {"_p_FIX__PosReqResult", "FIX::PosReqResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqStatus = {"_p_FIX__PosReqStatus", "FIX::PosReqStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqType = {"_p_FIX__PosReqType", "FIX::PosReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosTransType = {"_p_FIX__PosTransType", "FIX::PosTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosType = {"_p_FIX__PosType", "FIX::PosType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionCurrency = {"_p_FIX__PositionCurrency", "FIX::PositionCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionEffect = {"_p_FIX__PositionEffect", "FIX::PositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionLimit = {"_p_FIX__PositionLimit", "FIX::PositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PossDupFlag = {"_p_FIX__PossDupFlag", "FIX::PossDupFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PossResend = {"_p_FIX__PossResend", "FIX::PossResend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreTradeAnonymity = {"_p_FIX__PreTradeAnonymity", "FIX::PreTradeAnonymity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreallocMethod = {"_p_FIX__PreallocMethod", "FIX::PreallocMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PrevClosePx = {"_p_FIX__PrevClosePx", "FIX::PrevClosePx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreviouslyReported = {"_p_FIX__PreviouslyReported", "FIX::PreviouslyReported *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Price = {"_p_FIX__Price", "FIX::Price *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Price2 = {"_p_FIX__Price2", "FIX::Price2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceDelta = {"_p_FIX__PriceDelta", "FIX::PriceDelta *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceImprovement = {"_p_FIX__PriceImprovement", "FIX::PriceImprovement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceLimitType = {"_p_FIX__PriceLimitType", "FIX::PriceLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceProtectionScope = {"_p_FIX__PriceProtectionScope", "FIX::PriceProtectionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceQuoteMethod = {"_p_FIX__PriceQuoteMethod", "FIX::PriceQuoteMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceType = {"_p_FIX__PriceType", "FIX::PriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceUnitOfMeasure = {"_p_FIX__PriceUnitOfMeasure", "FIX::PriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceUnitOfMeasureQty = {"_p_FIX__PriceUnitOfMeasureQty", "FIX::PriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorSettlPrice = {"_p_FIX__PriorSettlPrice", "FIX::PriorSettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorSpreadIndicator = {"_p_FIX__PriorSpreadIndicator", "FIX::PriorSpreadIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorityIndicator = {"_p_FIX__PriorityIndicator", "FIX::PriorityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PrivateQuote = {"_p_FIX__PrivateQuote", "FIX::PrivateQuote *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProcessCode = {"_p_FIX__ProcessCode", "FIX::ProcessCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Product = {"_p_FIX__Product", "FIX::Product *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProductComplex = {"_p_FIX__ProductComplex", "FIX::ProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProgPeriodInterval = {"_p_FIX__ProgPeriodInterval", "FIX::ProgPeriodInterval *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProgRptReqs = {"_p_FIX__ProgRptReqs", "FIX::ProgRptReqs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PublishTrdIndicator = {"_p_FIX__PublishTrdIndicator", "FIX::PublishTrdIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PutOrCall = {"_p_FIX__PutOrCall", "FIX::PutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QTY = {"_p_FIX__QTY", "FIX::QTY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QtyType = {"_p_FIX__QtyType", "FIX::QtyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Quantity = {"_p_FIX__Quantity", "FIX::Quantity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuantityDate = {"_p_FIX__QuantityDate", "FIX::QuantityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuantityType = {"_p_FIX__QuantityType", "FIX::QuantityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteAckStatus = {"_p_FIX__QuoteAckStatus", "FIX::QuoteAckStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteCancelType = {"_p_FIX__QuoteCancelType", "FIX::QuoteCancelType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteCondition = {"_p_FIX__QuoteCondition", "FIX::QuoteCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryID = {"_p_FIX__QuoteEntryID", "FIX::QuoteEntryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryRejectReason = {"_p_FIX__QuoteEntryRejectReason", "FIX::QuoteEntryRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryStatus = {"_p_FIX__QuoteEntryStatus", "FIX::QuoteEntryStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteID = {"_p_FIX__QuoteID", "FIX::QuoteID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteMsgID = {"_p_FIX__QuoteMsgID", "FIX::QuoteMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuotePriceType = {"_p_FIX__QuotePriceType", "FIX::QuotePriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteQualifier = {"_p_FIX__QuoteQualifier", "FIX::QuoteQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRejectReason = {"_p_FIX__QuoteRejectReason", "FIX::QuoteRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteReqID = {"_p_FIX__QuoteReqID", "FIX::QuoteReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRequestRejectReason = {"_p_FIX__QuoteRequestRejectReason", "FIX::QuoteRequestRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRequestType = {"_p_FIX__QuoteRequestType", "FIX::QuoteRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRespID = {"_p_FIX__QuoteRespID", "FIX::QuoteRespID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRespType = {"_p_FIX__QuoteRespType", "FIX::QuoteRespType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteResponseLevel = {"_p_FIX__QuoteResponseLevel", "FIX::QuoteResponseLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteSetID = {"_p_FIX__QuoteSetID", "FIX::QuoteSetID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteSetValidUntilTime = {"_p_FIX__QuoteSetValidUntilTime", "FIX::QuoteSetValidUntilTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteStatus = {"_p_FIX__QuoteStatus", "FIX::QuoteStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteStatusReqID = {"_p_FIX__QuoteStatusReqID", "FIX::QuoteStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteType = {"_p_FIX__QuoteType", "FIX::QuoteType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RFQReqID = {"_p_FIX__RFQReqID", "FIX::RFQReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RateSource = {"_p_FIX__RateSource", "FIX::RateSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RateSourceType = {"_p_FIX__RateSourceType", "FIX::RateSourceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RatioQty = {"_p_FIX__RatioQty", "FIX::RatioQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RawData = {"_p_FIX__RawData", "FIX::RawData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RawDataLength = {"_p_FIX__RawDataLength", "FIX::RawDataLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReceivedDeptID = {"_p_FIX__ReceivedDeptID", "FIX::ReceivedDeptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RedemptionDate = {"_p_FIX__RedemptionDate", "FIX::RedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefAllocID = {"_p_FIX__RefAllocID", "FIX::RefAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplExtID = {"_p_FIX__RefApplExtID", "FIX::RefApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplID = {"_p_FIX__RefApplID", "FIX::RefApplID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplLastSeqNum = {"_p_FIX__RefApplLastSeqNum", "FIX::RefApplLastSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplReqID = {"_p_FIX__RefApplReqID", "FIX::RefApplReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplVerID = {"_p_FIX__RefApplVerID", "FIX::RefApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefCompID = {"_p_FIX__RefCompID", "FIX::RefCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefCstmApplVerID = {"_p_FIX__RefCstmApplVerID", "FIX::RefCstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefMsgType = {"_p_FIX__RefMsgType", "FIX::RefMsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrdIDReason = {"_p_FIX__RefOrdIDReason", "FIX::RefOrdIDReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrderID = {"_p_FIX__RefOrderID", "FIX::RefOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrderIDSource = {"_p_FIX__RefOrderIDSource", "FIX::RefOrderIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefSeqNum = {"_p_FIX__RefSeqNum", "FIX::RefSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefSubID = {"_p_FIX__RefSubID", "FIX::RefSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefTagID = {"_p_FIX__RefTagID", "FIX::RefTagID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReferencePage = {"_p_FIX__ReferencePage", "FIX::ReferencePage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefreshIndicator = {"_p_FIX__RefreshIndicator", "FIX::RefreshIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefreshQty = {"_p_FIX__RefreshQty", "FIX::RefreshQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistAcctType = {"_p_FIX__RegistAcctType", "FIX::RegistAcctType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistDetls = {"_p_FIX__RegistDetls", "FIX::RegistDetls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistDtls = {"_p_FIX__RegistDtls", "FIX::RegistDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistEmail = {"_p_FIX__RegistEmail", "FIX::RegistEmail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistID = {"_p_FIX__RegistID", "FIX::RegistID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRefID = {"_p_FIX__RegistRefID", "FIX::RegistRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRejReasonCode = {"_p_FIX__RegistRejReasonCode", "FIX::RegistRejReasonCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRejReasonText = {"_p_FIX__RegistRejReasonText", "FIX::RegistRejReasonText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistStatus = {"_p_FIX__RegistStatus", "FIX::RegistStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistTransType = {"_p_FIX__RegistTransType", "FIX::RegistTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RejectLogon = {"_p_FIX__RejectLogon", "FIX::RejectLogon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RejectText = {"_p_FIX__RejectText", "FIX::RejectText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelSymTransactTime = {"_p_FIX__RelSymTransactTime", "FIX::RelSymTransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatdSym = {"_p_FIX__RelatdSym", "FIX::RelatdSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartyID = {"_p_FIX__RelatedContextPartyID", "FIX::RelatedContextPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartyIDSource = {"_p_FIX__RelatedContextPartyIDSource", "FIX::RelatedContextPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartyRole = {"_p_FIX__RelatedContextPartyRole", "FIX::RelatedContextPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartySubID = {"_p_FIX__RelatedContextPartySubID", "FIX::RelatedContextPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedContextPartySubIDType = {"_p_FIX__RelatedContextPartySubIDType", "FIX::RelatedContextPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltID = {"_p_FIX__RelatedPartyAltID", "FIX::RelatedPartyAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltIDSource = {"_p_FIX__RelatedPartyAltIDSource", "FIX::RelatedPartyAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltSubID = {"_p_FIX__RelatedPartyAltSubID", "FIX::RelatedPartyAltSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyAltSubIDType = {"_p_FIX__RelatedPartyAltSubIDType", "FIX::RelatedPartyAltSubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyID = {"_p_FIX__RelatedPartyID", "FIX::RelatedPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyIDSource = {"_p_FIX__RelatedPartyIDSource", "FIX::RelatedPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartyRole = {"_p_FIX__RelatedPartyRole", "FIX::RelatedPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartySubID = {"_p_FIX__RelatedPartySubID", "FIX::RelatedPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatedPartySubIDType = {"_p_FIX__RelatedPartySubIDType", "FIX::RelatedPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskCFICode = {"_p_FIX__RelationshipRiskCFICode", "FIX::RelationshipRiskCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskCouponRate = {"_p_FIX__RelationshipRiskCouponRate", "FIX::RelationshipRiskCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskEncodedSecurityDesc = {"_p_FIX__RelationshipRiskEncodedSecurityDesc", "FIX::RelationshipRiskEncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen = {"_p_FIX__RelationshipRiskEncodedSecurityDescLen", "FIX::RelationshipRiskEncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskFlexibleIndicator = {"_p_FIX__RelationshipRiskFlexibleIndicator", "FIX::RelationshipRiskFlexibleIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskInstrumentMultiplier = {"_p_FIX__RelationshipRiskInstrumentMultiplier", "FIX::RelationshipRiskInstrumentMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskInstrumentOperator = {"_p_FIX__RelationshipRiskInstrumentOperator", "FIX::RelationshipRiskInstrumentOperator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskInstrumentSettlType = {"_p_FIX__RelationshipRiskInstrumentSettlType", "FIX::RelationshipRiskInstrumentSettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitAmount = {"_p_FIX__RelationshipRiskLimitAmount", "FIX::RelationshipRiskLimitAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitCurrency = {"_p_FIX__RelationshipRiskLimitCurrency", "FIX::RelationshipRiskLimitCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitPlatform = {"_p_FIX__RelationshipRiskLimitPlatform", "FIX::RelationshipRiskLimitPlatform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskLimitType = {"_p_FIX__RelationshipRiskLimitType", "FIX::RelationshipRiskLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskMaturityMonthYear = {"_p_FIX__RelationshipRiskMaturityMonthYear", "FIX::RelationshipRiskMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskMaturityTime = {"_p_FIX__RelationshipRiskMaturityTime", "FIX::RelationshipRiskMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskProduct = {"_p_FIX__RelationshipRiskProduct", "FIX::RelationshipRiskProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskProductComplex = {"_p_FIX__RelationshipRiskProductComplex", "FIX::RelationshipRiskProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskPutOrCall = {"_p_FIX__RelationshipRiskPutOrCall", "FIX::RelationshipRiskPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskRestructuringType = {"_p_FIX__RelationshipRiskRestructuringType", "FIX::RelationshipRiskRestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityAltID = {"_p_FIX__RelationshipRiskSecurityAltID", "FIX::RelationshipRiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityAltIDSource = {"_p_FIX__RelationshipRiskSecurityAltIDSource", "FIX::RelationshipRiskSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityDesc = {"_p_FIX__RelationshipRiskSecurityDesc", "FIX::RelationshipRiskSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityExchange = {"_p_FIX__RelationshipRiskSecurityExchange", "FIX::RelationshipRiskSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityGroup = {"_p_FIX__RelationshipRiskSecurityGroup", "FIX::RelationshipRiskSecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityID = {"_p_FIX__RelationshipRiskSecurityID", "FIX::RelationshipRiskSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityIDSource = {"_p_FIX__RelationshipRiskSecurityIDSource", "FIX::RelationshipRiskSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecuritySubType = {"_p_FIX__RelationshipRiskSecuritySubType", "FIX::RelationshipRiskSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSecurityType = {"_p_FIX__RelationshipRiskSecurityType", "FIX::RelationshipRiskSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSeniority = {"_p_FIX__RelationshipRiskSeniority", "FIX::RelationshipRiskSeniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSymbol = {"_p_FIX__RelationshipRiskSymbol", "FIX::RelationshipRiskSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskSymbolSfx = {"_p_FIX__RelationshipRiskSymbolSfx", "FIX::RelationshipRiskSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskWarningLevelName = {"_p_FIX__RelationshipRiskWarningLevelName", "FIX::RelationshipRiskWarningLevelName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelationshipRiskWarningLevelPercent = {"_p_FIX__RelationshipRiskWarningLevelPercent", "FIX::RelationshipRiskWarningLevelPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepeatedTag = {"_p_FIX__RepeatedTag", "FIX::RepeatedTag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepeatingGroupCountMismatch = {"_p_FIX__RepeatingGroupCountMismatch", "FIX::RepeatingGroupCountMismatch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepoCollateralSecurityType = {"_p_FIX__RepoCollateralSecurityType", "FIX::RepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportToExch = {"_p_FIX__ReportToExch", "FIX::ReportToExch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportedPx = {"_p_FIX__ReportedPx", "FIX::ReportedPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportedPxDiff = {"_p_FIX__ReportedPxDiff", "FIX::ReportedPxDiff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepurchaseRate = {"_p_FIX__RepurchaseRate", "FIX::RepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepurchaseTerm = {"_p_FIX__RepurchaseTerm", "FIX::RepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RequestedPartyRole = {"_p_FIX__RequestedPartyRole", "FIX::RequestedPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RequiredTagMissing = {"_p_FIX__RequiredTagMissing", "FIX::RequiredTagMissing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResetSeqNumFlag = {"_p_FIX__ResetSeqNumFlag", "FIX::ResetSeqNumFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RespondentType = {"_p_FIX__RespondentType", "FIX::RespondentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResponseDestination = {"_p_FIX__ResponseDestination", "FIX::ResponseDestination *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResponseTransportType = {"_p_FIX__ResponseTransportType", "FIX::ResponseTransportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RestructuringType = {"_p_FIX__RestructuringType", "FIX::RestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReversalIndicator = {"_p_FIX__ReversalIndicator", "FIX::ReversalIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskCFICode = {"_p_FIX__RiskCFICode", "FIX::RiskCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskCouponRate = {"_p_FIX__RiskCouponRate", "FIX::RiskCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskEncodedSecurityDesc = {"_p_FIX__RiskEncodedSecurityDesc", "FIX::RiskEncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskEncodedSecurityDescLen = {"_p_FIX__RiskEncodedSecurityDescLen", "FIX::RiskEncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskFlexibleIndicator = {"_p_FIX__RiskFlexibleIndicator", "FIX::RiskFlexibleIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskFreeRate = {"_p_FIX__RiskFreeRate", "FIX::RiskFreeRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskInstrumentMultiplier = {"_p_FIX__RiskInstrumentMultiplier", "FIX::RiskInstrumentMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskInstrumentOperator = {"_p_FIX__RiskInstrumentOperator", "FIX::RiskInstrumentOperator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskInstrumentSettlType = {"_p_FIX__RiskInstrumentSettlType", "FIX::RiskInstrumentSettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitAmount = {"_p_FIX__RiskLimitAmount", "FIX::RiskLimitAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitCurrency = {"_p_FIX__RiskLimitCurrency", "FIX::RiskLimitCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitPlatform = {"_p_FIX__RiskLimitPlatform", "FIX::RiskLimitPlatform *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskLimitType = {"_p_FIX__RiskLimitType", "FIX::RiskLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskMaturityMonthYear = {"_p_FIX__RiskMaturityMonthYear", "FIX::RiskMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskMaturityTime = {"_p_FIX__RiskMaturityTime", "FIX::RiskMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskProduct = {"_p_FIX__RiskProduct", "FIX::RiskProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskProductComplex = {"_p_FIX__RiskProductComplex", "FIX::RiskProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskPutOrCall = {"_p_FIX__RiskPutOrCall", "FIX::RiskPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskRestructuringType = {"_p_FIX__RiskRestructuringType", "FIX::RiskRestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityAltID = {"_p_FIX__RiskSecurityAltID", "FIX::RiskSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityAltIDSource = {"_p_FIX__RiskSecurityAltIDSource", "FIX::RiskSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityDesc = {"_p_FIX__RiskSecurityDesc", "FIX::RiskSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityExchange = {"_p_FIX__RiskSecurityExchange", "FIX::RiskSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityGroup = {"_p_FIX__RiskSecurityGroup", "FIX::RiskSecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityID = {"_p_FIX__RiskSecurityID", "FIX::RiskSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityIDSource = {"_p_FIX__RiskSecurityIDSource", "FIX::RiskSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecuritySubType = {"_p_FIX__RiskSecuritySubType", "FIX::RiskSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSecurityType = {"_p_FIX__RiskSecurityType", "FIX::RiskSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSeniority = {"_p_FIX__RiskSeniority", "FIX::RiskSeniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSymbol = {"_p_FIX__RiskSymbol", "FIX::RiskSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskSymbolSfx = {"_p_FIX__RiskSymbolSfx", "FIX::RiskSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskWarningLevelName = {"_p_FIX__RiskWarningLevelName", "FIX::RiskWarningLevelName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskWarningLevelPercent = {"_p_FIX__RiskWarningLevelPercent", "FIX::RiskWarningLevelPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RndPx = {"_p_FIX__RndPx", "FIX::RndPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyID = {"_p_FIX__RootPartyID", "FIX::RootPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyIDSource = {"_p_FIX__RootPartyIDSource", "FIX::RootPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyRole = {"_p_FIX__RootPartyRole", "FIX::RootPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartySubID = {"_p_FIX__RootPartySubID", "FIX::RootPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartySubIDType = {"_p_FIX__RootPartySubIDType", "FIX::RootPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundLot = {"_p_FIX__RoundLot", "FIX::RoundLot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundingDirection = {"_p_FIX__RoundingDirection", "FIX::RoundingDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundingModulus = {"_p_FIX__RoundingModulus", "FIX::RoundingModulus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoutingID = {"_p_FIX__RoutingID", "FIX::RoutingID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoutingType = {"_p_FIX__RoutingType", "FIX::RoutingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RptSeq = {"_p_FIX__RptSeq", "FIX::RptSeq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RptSys = {"_p_FIX__RptSys", "FIX::RptSys *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Rule80A = {"_p_FIX__Rule80A", "FIX::Rule80A *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RuntimeError = {"_p_FIX__RuntimeError", "FIX::RuntimeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SEQNUM = {"_p_FIX__SEQNUM", "FIX::SEQNUM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__STRING = {"_p_FIX__STRING", "FIX::STRING *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Scope = {"_p_FIX__Scope", "FIX::Scope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ScreenLog = {"_p_FIX__ScreenLog", "FIX::ScreenLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ScreenLogFactory = {"_p_FIX__ScreenLogFactory", "FIX::ScreenLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecDefStatus = {"_p_FIX__SecDefStatus", "FIX::SecDefStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryAllocID = {"_p_FIX__SecondaryAllocID", "FIX::SecondaryAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryClOrdID = {"_p_FIX__SecondaryClOrdID", "FIX::SecondaryClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryDisplayQty = {"_p_FIX__SecondaryDisplayQty", "FIX::SecondaryDisplayQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryExecID = {"_p_FIX__SecondaryExecID", "FIX::SecondaryExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryFirmTradeID = {"_p_FIX__SecondaryFirmTradeID", "FIX::SecondaryFirmTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryHighLimitPrice = {"_p_FIX__SecondaryHighLimitPrice", "FIX::SecondaryHighLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryIndividualAllocID = {"_p_FIX__SecondaryIndividualAllocID", "FIX::SecondaryIndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryLowLimitPrice = {"_p_FIX__SecondaryLowLimitPrice", "FIX::SecondaryLowLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryOrderID = {"_p_FIX__SecondaryOrderID", "FIX::SecondaryOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryPriceLimitType = {"_p_FIX__SecondaryPriceLimitType", "FIX::SecondaryPriceLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeID = {"_p_FIX__SecondaryTradeID", "FIX::SecondaryTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeReportID = {"_p_FIX__SecondaryTradeReportID", "FIX::SecondaryTradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeReportRefID = {"_p_FIX__SecondaryTradeReportRefID", "FIX::SecondaryTradeReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradingReferencePrice = {"_p_FIX__SecondaryTradingReferencePrice", "FIX::SecondaryTradingReferencePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTrdType = {"_p_FIX__SecondaryTrdType", "FIX::SecondaryTrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecureData = {"_p_FIX__SecureData", "FIX::SecureData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecureDataLen = {"_p_FIX__SecureDataLen", "FIX::SecureDataLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityAltID = {"_p_FIX__SecurityAltID", "FIX::SecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityAltIDSource = {"_p_FIX__SecurityAltIDSource", "FIX::SecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityDesc = {"_p_FIX__SecurityDesc", "FIX::SecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityExchange = {"_p_FIX__SecurityExchange", "FIX::SecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityGroup = {"_p_FIX__SecurityGroup", "FIX::SecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityID = {"_p_FIX__SecurityID", "FIX::SecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityIDSource = {"_p_FIX__SecurityIDSource", "FIX::SecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListDesc = {"_p_FIX__SecurityListDesc", "FIX::SecurityListDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListID = {"_p_FIX__SecurityListID", "FIX::SecurityListID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListRefID = {"_p_FIX__SecurityListRefID", "FIX::SecurityListRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListRequestType = {"_p_FIX__SecurityListRequestType", "FIX::SecurityListRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListType = {"_p_FIX__SecurityListType", "FIX::SecurityListType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListTypeSource = {"_p_FIX__SecurityListTypeSource", "FIX::SecurityListTypeSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityReportID = {"_p_FIX__SecurityReportID", "FIX::SecurityReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityReqID = {"_p_FIX__SecurityReqID", "FIX::SecurityReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityRequestResult = {"_p_FIX__SecurityRequestResult", "FIX::SecurityRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityRequestType = {"_p_FIX__SecurityRequestType", "FIX::SecurityRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityResponseID = {"_p_FIX__SecurityResponseID", "FIX::SecurityResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityResponseType = {"_p_FIX__SecurityResponseType", "FIX::SecurityResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentAcctName = {"_p_FIX__SecuritySettlAgentAcctName", "FIX::SecuritySettlAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentAcctNum = {"_p_FIX__SecuritySettlAgentAcctNum", "FIX::SecuritySettlAgentAcctNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentCode = {"_p_FIX__SecuritySettlAgentCode", "FIX::SecuritySettlAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentContactName = {"_p_FIX__SecuritySettlAgentContactName", "FIX::SecuritySettlAgentContactName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentContactPhone = {"_p_FIX__SecuritySettlAgentContactPhone", "FIX::SecuritySettlAgentContactPhone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentName = {"_p_FIX__SecuritySettlAgentName", "FIX::SecuritySettlAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityStatus = {"_p_FIX__SecurityStatus", "FIX::SecurityStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityStatusReqID = {"_p_FIX__SecurityStatusReqID", "FIX::SecurityStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySubType = {"_p_FIX__SecuritySubType", "FIX::SecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityTradingEvent = {"_p_FIX__SecurityTradingEvent", "FIX::SecurityTradingEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityTradingStatus = {"_p_FIX__SecurityTradingStatus", "FIX::SecurityTradingStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityType = {"_p_FIX__SecurityType", "FIX::SecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityUpdateAction = {"_p_FIX__SecurityUpdateAction", "FIX::SecurityUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXML = {"_p_FIX__SecurityXML", "FIX::SecurityXML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXMLLen = {"_p_FIX__SecurityXMLLen", "FIX::SecurityXMLLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXMLSchema = {"_p_FIX__SecurityXMLSchema", "FIX::SecurityXMLSchema *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SellVolume = {"_p_FIX__SellVolume", "FIX::SellVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SellerDays = {"_p_FIX__SellerDays", "FIX::SellerDays *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderCompID = {"_p_FIX__SenderCompID", "FIX::SenderCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderLocationID = {"_p_FIX__SenderLocationID", "FIX::SenderLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderSubID = {"_p_FIX__SenderSubID", "FIX::SenderSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SendingDate = {"_p_FIX__SendingDate", "FIX::SendingDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SendingTime = {"_p_FIX__SendingTime", "FIX::SendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Seniority = {"_p_FIX__Seniority", "FIX::Seniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Session = {"_p_FIX__Session", "FIX::Session *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionID = {"_p_FIX__SessionID", "FIX::SessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionNotFound = {"_p_FIX__SessionNotFound", "FIX::SessionNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionRejectReason = {"_p_FIX__SessionRejectReason", "FIX::SessionRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionSettings = {"_p_FIX__SessionSettings", "FIX::SessionSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionStatus = {"_p_FIX__SessionStatus", "FIX::SessionStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlBrkrCode = {"_p_FIX__SettlBrkrCode", "FIX::SettlBrkrCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrAmt = {"_p_FIX__SettlCurrAmt", "FIX::SettlCurrAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrBidFxRate = {"_p_FIX__SettlCurrBidFxRate", "FIX::SettlCurrBidFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrFxRate = {"_p_FIX__SettlCurrFxRate", "FIX::SettlCurrFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrFxRateCalc = {"_p_FIX__SettlCurrFxRateCalc", "FIX::SettlCurrFxRateCalc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrOfferFxRate = {"_p_FIX__SettlCurrOfferFxRate", "FIX::SettlCurrOfferFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrency = {"_p_FIX__SettlCurrency", "FIX::SettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDate = {"_p_FIX__SettlDate", "FIX::SettlDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDate2 = {"_p_FIX__SettlDate2", "FIX::SettlDate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDeliveryType = {"_p_FIX__SettlDeliveryType", "FIX::SettlDeliveryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDepositoryCode = {"_p_FIX__SettlDepositoryCode", "FIX::SettlDepositoryCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstCode = {"_p_FIX__SettlInstCode", "FIX::SettlInstCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstID = {"_p_FIX__SettlInstID", "FIX::SettlInstID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstMode = {"_p_FIX__SettlInstMode", "FIX::SettlInstMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstMsgID = {"_p_FIX__SettlInstMsgID", "FIX::SettlInstMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstRefID = {"_p_FIX__SettlInstRefID", "FIX::SettlInstRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstReqID = {"_p_FIX__SettlInstReqID", "FIX::SettlInstReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstReqRejCode = {"_p_FIX__SettlInstReqRejCode", "FIX::SettlInstReqRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstSource = {"_p_FIX__SettlInstSource", "FIX::SettlInstSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstTransType = {"_p_FIX__SettlInstTransType", "FIX::SettlInstTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlLocation = {"_p_FIX__SettlLocation", "FIX::SettlLocation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlMethod = {"_p_FIX__SettlMethod", "FIX::SettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligID = {"_p_FIX__SettlObligID", "FIX::SettlObligID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligMode = {"_p_FIX__SettlObligMode", "FIX::SettlObligMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligMsgID = {"_p_FIX__SettlObligMsgID", "FIX::SettlObligMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligRefID = {"_p_FIX__SettlObligRefID", "FIX::SettlObligRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligSource = {"_p_FIX__SettlObligSource", "FIX::SettlObligSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligTransType = {"_p_FIX__SettlObligTransType", "FIX::SettlObligTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyID = {"_p_FIX__SettlPartyID", "FIX::SettlPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyIDSource = {"_p_FIX__SettlPartyIDSource", "FIX::SettlPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyRole = {"_p_FIX__SettlPartyRole", "FIX::SettlPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartySubID = {"_p_FIX__SettlPartySubID", "FIX::SettlPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartySubIDType = {"_p_FIX__SettlPartySubIDType", "FIX::SettlPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPrice = {"_p_FIX__SettlPrice", "FIX::SettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPriceType = {"_p_FIX__SettlPriceType", "FIX::SettlPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlSessID = {"_p_FIX__SettlSessID", "FIX::SettlSessID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlSessSubID = {"_p_FIX__SettlSessSubID", "FIX::SettlSessSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlType = {"_p_FIX__SettlType", "FIX::SettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettleOnOpenFlag = {"_p_FIX__SettleOnOpenFlag", "FIX::SettleOnOpenFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlementCycleNo = {"_p_FIX__SettlementCycleNo", "FIX::SettlementCycleNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlmntTyp = {"_p_FIX__SettlmntTyp", "FIX::SettlmntTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SharedCommission = {"_p_FIX__SharedCommission", "FIX::SharedCommission *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Shares = {"_p_FIX__Shares", "FIX::Shares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ShortQty = {"_p_FIX__ShortQty", "FIX::ShortQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ShortSaleReason = {"_p_FIX__ShortSaleReason", "FIX::ShortSaleReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Side = {"_p_FIX__Side", "FIX::Side *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideComplianceID = {"_p_FIX__SideComplianceID", "FIX::SideComplianceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideCurrency = {"_p_FIX__SideCurrency", "FIX::SideCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideExecID = {"_p_FIX__SideExecID", "FIX::SideExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideFillStationCd = {"_p_FIX__SideFillStationCd", "FIX::SideFillStationCd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideGrossTradeAmt = {"_p_FIX__SideGrossTradeAmt", "FIX::SideGrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideLastQty = {"_p_FIX__SideLastQty", "FIX::SideLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideLiquidityInd = {"_p_FIX__SideLiquidityInd", "FIX::SideLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideMultiLegReportingType = {"_p_FIX__SideMultiLegReportingType", "FIX::SideMultiLegReportingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideQty = {"_p_FIX__SideQty", "FIX::SideQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideReasonCd = {"_p_FIX__SideReasonCd", "FIX::SideReasonCd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideSettlCurrency = {"_p_FIX__SideSettlCurrency", "FIX::SideSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTimeInForce = {"_p_FIX__SideTimeInForce", "FIX::SideTimeInForce *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTradeReportID = {"_p_FIX__SideTradeReportID", "FIX::SideTradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestamp = {"_p_FIX__SideTrdRegTimestamp", "FIX::SideTrdRegTimestamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestampSrc = {"_p_FIX__SideTrdRegTimestampSrc", "FIX::SideTrdRegTimestampSrc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestampType = {"_p_FIX__SideTrdRegTimestampType", "FIX::SideTrdRegTimestampType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdSubTyp = {"_p_FIX__SideTrdSubTyp", "FIX::SideTrdSubTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValue1 = {"_p_FIX__SideValue1", "FIX::SideValue1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValue2 = {"_p_FIX__SideValue2", "FIX::SideValue2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValueInd = {"_p_FIX__SideValueInd", "FIX::SideValueInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Signature = {"_p_FIX__Signature", "FIX::Signature *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SignatureLength = {"_p_FIX__SignatureLength", "FIX::SignatureLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketAcceptor = {"_p_FIX__SocketAcceptor", "FIX::SocketAcceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketCloseFailed = {"_p_FIX__SocketCloseFailed", "FIX::SocketCloseFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketException = {"_p_FIX__SocketException", "FIX::SocketException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketInitiator = {"_p_FIX__SocketInitiator", "FIX::SocketInitiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketRecvFailed = {"_p_FIX__SocketRecvFailed", "FIX::SocketRecvFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketSendFailed = {"_p_FIX__SocketSendFailed", "FIX::SocketSendFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SolicitedFlag = {"_p_FIX__SolicitedFlag", "FIX::SolicitedFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Spread = {"_p_FIX__Spread", "FIX::Spread *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SpreadToBenchmark = {"_p_FIX__SpreadToBenchmark", "FIX::SpreadToBenchmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbID = {"_p_FIX__StandInstDbID", "FIX::StandInstDbID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbName = {"_p_FIX__StandInstDbName", "FIX::StandInstDbName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbType = {"_p_FIX__StandInstDbType", "FIX::StandInstDbType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartCash = {"_p_FIX__StartCash", "FIX::StartCash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartDate = {"_p_FIX__StartDate", "FIX::StartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartMaturityMonthYear = {"_p_FIX__StartMaturityMonthYear", "FIX::StartMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartStrikePxRange = {"_p_FIX__StartStrikePxRange", "FIX::StartStrikePxRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartTickPriceRange = {"_p_FIX__StartTickPriceRange", "FIX::StartTickPriceRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StateOrProvinceOfIssue = {"_p_FIX__StateOrProvinceOfIssue", "FIX::StateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatsType = {"_p_FIX__StatsType", "FIX::StatsType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatusText = {"_p_FIX__StatusText", "FIX::StatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatusValue = {"_p_FIX__StatusValue", "FIX::StatusValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StipulationType = {"_p_FIX__StipulationType", "FIX::StipulationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StipulationValue = {"_p_FIX__StipulationValue", "FIX::StipulationValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StopPx = {"_p_FIX__StopPx", "FIX::StopPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterName = {"_p_FIX__StrategyParameterName", "FIX::StrategyParameterName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterType = {"_p_FIX__StrategyParameterType", "FIX::StrategyParameterType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterValue = {"_p_FIX__StrategyParameterValue", "FIX::StrategyParameterValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnAckType = {"_p_FIX__StreamAsgnAckType", "FIX::StreamAsgnAckType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnRejReason = {"_p_FIX__StreamAsgnRejReason", "FIX::StreamAsgnRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnReqID = {"_p_FIX__StreamAsgnReqID", "FIX::StreamAsgnReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnReqType = {"_p_FIX__StreamAsgnReqType", "FIX::StreamAsgnReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnRptID = {"_p_FIX__StreamAsgnRptID", "FIX::StreamAsgnRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnType = {"_p_FIX__StreamAsgnType", "FIX::StreamAsgnType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeCurrency = {"_p_FIX__StrikeCurrency", "FIX::StrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeExerciseStyle = {"_p_FIX__StrikeExerciseStyle", "FIX::StrikeExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeIncrement = {"_p_FIX__StrikeIncrement", "FIX::StrikeIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeMultiplier = {"_p_FIX__StrikeMultiplier", "FIX::StrikeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePrice = {"_p_FIX__StrikePrice", "FIX::StrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceBoundaryMethod = {"_p_FIX__StrikePriceBoundaryMethod", "FIX::StrikePriceBoundaryMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceBoundaryPrecision = {"_p_FIX__StrikePriceBoundaryPrecision", "FIX::StrikePriceBoundaryPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceDeterminationMethod = {"_p_FIX__StrikePriceDeterminationMethod", "FIX::StrikePriceDeterminationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeRuleID = {"_p_FIX__StrikeRuleID", "FIX::StrikeRuleID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeTime = {"_p_FIX__StrikeTime", "FIX::StrikeTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeValue = {"_p_FIX__StrikeValue", "FIX::StrikeValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StringField = {"_p_FIX__StringField", "FIX::StringField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Subject = {"_p_FIX__Subject", "FIX::Subject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SubscriptionRequestType = {"_p_FIX__SubscriptionRequestType", "FIX::SubscriptionRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SwapPoints = {"_p_FIX__SwapPoints", "FIX::SwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Symbol = {"_p_FIX__Symbol", "FIX::Symbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SymbolSfx = {"_p_FIX__SymbolSfx", "FIX::SymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SynchronizedApplication = {"_p_FIX__SynchronizedApplication", "FIX::SynchronizedApplication *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TYPE__Type = {"_p_FIX__TYPE__Type", "FIX::TYPE::Type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTIMEONLY = {"_p_FIX__TZTIMEONLY", "FIX::TZTIMEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTIMESTAMP = {"_p_FIX__TZTIMESTAMP", "FIX::TZTIMESTAMP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTransactTime = {"_p_FIX__TZTransactTime", "FIX::TZTransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TagNotDefinedForMessage = {"_p_FIX__TagNotDefinedForMessage", "FIX::TagNotDefinedForMessage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TagOutOfOrder = {"_p_FIX__TagOutOfOrder", "FIX::TagOutOfOrder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetCompID = {"_p_FIX__TargetCompID", "FIX::TargetCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetLocationID = {"_p_FIX__TargetLocationID", "FIX::TargetLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyID = {"_p_FIX__TargetPartyID", "FIX::TargetPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyIDSource = {"_p_FIX__TargetPartyIDSource", "FIX::TargetPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyRole = {"_p_FIX__TargetPartyRole", "FIX::TargetPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategy = {"_p_FIX__TargetStrategy", "FIX::TargetStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategyParameters = {"_p_FIX__TargetStrategyParameters", "FIX::TargetStrategyParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategyPerformance = {"_p_FIX__TargetStrategyPerformance", "FIX::TargetStrategyPerformance *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetSubID = {"_p_FIX__TargetSubID", "FIX::TargetSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TaxAdvantageType = {"_p_FIX__TaxAdvantageType", "FIX::TaxAdvantageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TerminationType = {"_p_FIX__TerminationType", "FIX::TerminationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TestMessageIndicator = {"_p_FIX__TestMessageIndicator", "FIX::TestMessageIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TestReqID = {"_p_FIX__TestReqID", "FIX::TestReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Text = {"_p_FIX__Text", "FIX::Text *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ThresholdAmount = {"_p_FIX__ThresholdAmount", "FIX::ThresholdAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickDirection = {"_p_FIX__TickDirection", "FIX::TickDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickIncrement = {"_p_FIX__TickIncrement", "FIX::TickIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickRuleType = {"_p_FIX__TickRuleType", "FIX::TickRuleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TierCode = {"_p_FIX__TierCode", "FIX::TierCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeBracket = {"_p_FIX__TimeBracket", "FIX::TimeBracket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeInForce = {"_p_FIX__TimeInForce", "FIX::TimeInForce *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeToExpiration = {"_p_FIX__TimeToExpiration", "FIX::TimeToExpiration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeUnit = {"_p_FIX__TimeUnit", "FIX::TimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoAccQuotes = {"_p_FIX__TotNoAccQuotes", "FIX::TotNoAccQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoAllocs = {"_p_FIX__TotNoAllocs", "FIX::TotNoAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoCxldQuotes = {"_p_FIX__TotNoCxldQuotes", "FIX::TotNoCxldQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoFills = {"_p_FIX__TotNoFills", "FIX::TotNoFills *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoOrders = {"_p_FIX__TotNoOrders", "FIX::TotNoOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoPartyList = {"_p_FIX__TotNoPartyList", "FIX::TotNoPartyList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoQuoteEntries = {"_p_FIX__TotNoQuoteEntries", "FIX::TotNoQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoRejQuotes = {"_p_FIX__TotNoRejQuotes", "FIX::TotNoRejQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoRelatedSym = {"_p_FIX__TotNoRelatedSym", "FIX::TotNoRelatedSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoSecurityTypes = {"_p_FIX__TotNoSecurityTypes", "FIX::TotNoSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoStrikes = {"_p_FIX__TotNoStrikes", "FIX::TotNoStrikes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumAssignmentReports = {"_p_FIX__TotNumAssignmentReports", "FIX::TotNumAssignmentReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumReports = {"_p_FIX__TotNumReports", "FIX::TotNumReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumTradeReports = {"_p_FIX__TotNumTradeReports", "FIX::TotNumTradeReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotQuoteEntries = {"_p_FIX__TotQuoteEntries", "FIX::TotQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalAccruedInterestAmt = {"_p_FIX__TotalAccruedInterestAmt", "FIX::TotalAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalAffectedOrders = {"_p_FIX__TotalAffectedOrders", "FIX::TotalAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNetValue = {"_p_FIX__TotalNetValue", "FIX::TotalNetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumPosReports = {"_p_FIX__TotalNumPosReports", "FIX::TotalNumPosReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumSecurities = {"_p_FIX__TotalNumSecurities", "FIX::TotalNumSecurities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumSecurityTypes = {"_p_FIX__TotalNumSecurityTypes", "FIX::TotalNumSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalTakedown = {"_p_FIX__TotalTakedown", "FIX::TotalTakedown *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTraded = {"_p_FIX__TotalVolumeTraded", "FIX::TotalVolumeTraded *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTradedDate = {"_p_FIX__TotalVolumeTradedDate", "FIX::TotalVolumeTradedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTradedTime = {"_p_FIX__TotalVolumeTradedTime", "FIX::TotalVolumeTradedTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesCloseTime = {"_p_FIX__TradSesCloseTime", "FIX::TradSesCloseTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesEndTime = {"_p_FIX__TradSesEndTime", "FIX::TradSesEndTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesEvent = {"_p_FIX__TradSesEvent", "FIX::TradSesEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesMethod = {"_p_FIX__TradSesMethod", "FIX::TradSesMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesMode = {"_p_FIX__TradSesMode", "FIX::TradSesMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesOpenTime = {"_p_FIX__TradSesOpenTime", "FIX::TradSesOpenTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesPreCloseTime = {"_p_FIX__TradSesPreCloseTime", "FIX::TradSesPreCloseTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesReqID = {"_p_FIX__TradSesReqID", "FIX::TradSesReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStartTime = {"_p_FIX__TradSesStartTime", "FIX::TradSesStartTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStatus = {"_p_FIX__TradSesStatus", "FIX::TradSesStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStatusRejReason = {"_p_FIX__TradSesStatusRejReason", "FIX::TradSesStatusRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesUpdateAction = {"_p_FIX__TradSesUpdateAction", "FIX::TradSesUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeAllocIndicator = {"_p_FIX__TradeAllocIndicator", "FIX::TradeAllocIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeCondition = {"_p_FIX__TradeCondition", "FIX::TradeCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeDate = {"_p_FIX__TradeDate", "FIX::TradeDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeHandlingInstr = {"_p_FIX__TradeHandlingInstr", "FIX::TradeHandlingInstr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeID = {"_p_FIX__TradeID", "FIX::TradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeInputDevice = {"_p_FIX__TradeInputDevice", "FIX::TradeInputDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeInputSource = {"_p_FIX__TradeInputSource", "FIX::TradeInputSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeLegRefID = {"_p_FIX__TradeLegRefID", "FIX::TradeLegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeLinkID = {"_p_FIX__TradeLinkID", "FIX::TradeLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeOriginationDate = {"_p_FIX__TradeOriginationDate", "FIX::TradeOriginationDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradePublishIndicator = {"_p_FIX__TradePublishIndicator", "FIX::TradePublishIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportID = {"_p_FIX__TradeReportID", "FIX::TradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportRefID = {"_p_FIX__TradeReportRefID", "FIX::TradeReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportRejectReason = {"_p_FIX__TradeReportRejectReason", "FIX::TradeReportRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportTransType = {"_p_FIX__TradeReportTransType", "FIX::TradeReportTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportType = {"_p_FIX__TradeReportType", "FIX::TradeReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestID = {"_p_FIX__TradeRequestID", "FIX::TradeRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestResult = {"_p_FIX__TradeRequestResult", "FIX::TradeRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestStatus = {"_p_FIX__TradeRequestStatus", "FIX::TradeRequestStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestType = {"_p_FIX__TradeRequestType", "FIX::TradeRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeType = {"_p_FIX__TradeType", "FIX::TradeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeVolume = {"_p_FIX__TradeVolume", "FIX::TradeVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradedFlatSwitch = {"_p_FIX__TradedFlatSwitch", "FIX::TradedFlatSwitch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingCurrency = {"_p_FIX__TradingCurrency", "FIX::TradingCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingReferencePrice = {"_p_FIX__TradingReferencePrice", "FIX::TradingReferencePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionDesc = {"_p_FIX__TradingSessionDesc", "FIX::TradingSessionDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionID = {"_p_FIX__TradingSessionID", "FIX::TradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionSubID = {"_p_FIX__TradingSessionSubID", "FIX::TradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransBkdTime = {"_p_FIX__TransBkdTime", "FIX::TransBkdTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransactTime = {"_p_FIX__TransactTime", "FIX::TransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransferReason = {"_p_FIX__TransferReason", "FIX::TransferReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdMatchID = {"_p_FIX__TrdMatchID", "FIX::TrdMatchID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestamp = {"_p_FIX__TrdRegTimestamp", "FIX::TrdRegTimestamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestampOrigin = {"_p_FIX__TrdRegTimestampOrigin", "FIX::TrdRegTimestampOrigin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestampType = {"_p_FIX__TrdRegTimestampType", "FIX::TrdRegTimestampType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRepIndicator = {"_p_FIX__TrdRepIndicator", "FIX::TrdRepIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRepPartyRole = {"_p_FIX__TrdRepPartyRole", "FIX::TrdRepPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRptStatus = {"_p_FIX__TrdRptStatus", "FIX::TrdRptStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdSubType = {"_p_FIX__TrdSubType", "FIX::TrdSubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdType = {"_p_FIX__TrdType", "FIX::TrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerAction = {"_p_FIX__TriggerAction", "FIX::TriggerAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerNewPrice = {"_p_FIX__TriggerNewPrice", "FIX::TriggerNewPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerNewQty = {"_p_FIX__TriggerNewQty", "FIX::TriggerNewQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerOrderType = {"_p_FIX__TriggerOrderType", "FIX::TriggerOrderType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPrice = {"_p_FIX__TriggerPrice", "FIX::TriggerPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceDirection = {"_p_FIX__TriggerPriceDirection", "FIX::TriggerPriceDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceType = {"_p_FIX__TriggerPriceType", "FIX::TriggerPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceTypeScope = {"_p_FIX__TriggerPriceTypeScope", "FIX::TriggerPriceTypeScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityDesc = {"_p_FIX__TriggerSecurityDesc", "FIX::TriggerSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityID = {"_p_FIX__TriggerSecurityID", "FIX::TriggerSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityIDSource = {"_p_FIX__TriggerSecurityIDSource", "FIX::TriggerSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSymbol = {"_p_FIX__TriggerSymbol", "FIX::TriggerSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerTradingSessionID = {"_p_FIX__TriggerTradingSessionID", "FIX::TriggerTradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerTradingSessionSubID = {"_p_FIX__TriggerTradingSessionSubID", "FIX::TriggerTradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerType = {"_p_FIX__TriggerType", "FIX::TriggerType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__URLLink = {"_p_FIX__URLLink", "FIX::URLLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCDATEONLY = {"_p_FIX__UTCDATEONLY", "FIX::UTCDATEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCTIMEONLY = {"_p_FIX__UTCTIMEONLY", "FIX::UTCTIMEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCTIMESTAMP = {"_p_FIX__UTCTIMESTAMP", "FIX::UTCTIMESTAMP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAdjustedQuantity = {"_p_FIX__UnderlyingAdjustedQuantity", "FIX::UnderlyingAdjustedQuantity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAllocationPercent = {"_p_FIX__UnderlyingAllocationPercent", "FIX::UnderlyingAllocationPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAttachmentPoint = {"_p_FIX__UnderlyingAttachmentPoint", "FIX::UnderlyingAttachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCFICode = {"_p_FIX__UnderlyingCFICode", "FIX::UnderlyingCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCPProgram = {"_p_FIX__UnderlyingCPProgram", "FIX::UnderlyingCPProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCPRegType = {"_p_FIX__UnderlyingCPRegType", "FIX::UnderlyingCPRegType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCapValue = {"_p_FIX__UnderlyingCapValue", "FIX::UnderlyingCapValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCashAmount = {"_p_FIX__UnderlyingCashAmount", "FIX::UnderlyingCashAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCashType = {"_p_FIX__UnderlyingCashType", "FIX::UnderlyingCashType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCollectAmount = {"_p_FIX__UnderlyingCollectAmount", "FIX::UnderlyingCollectAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingContractMultiplier = {"_p_FIX__UnderlyingContractMultiplier", "FIX::UnderlyingContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingContractMultiplierUnit = {"_p_FIX__UnderlyingContractMultiplierUnit", "FIX::UnderlyingContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCountryOfIssue = {"_p_FIX__UnderlyingCountryOfIssue", "FIX::UnderlyingCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCouponPaymentDate = {"_p_FIX__UnderlyingCouponPaymentDate", "FIX::UnderlyingCouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCouponRate = {"_p_FIX__UnderlyingCouponRate", "FIX::UnderlyingCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCreditRating = {"_p_FIX__UnderlyingCreditRating", "FIX::UnderlyingCreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCurrency = {"_p_FIX__UnderlyingCurrency", "FIX::UnderlyingCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCurrentValue = {"_p_FIX__UnderlyingCurrentValue", "FIX::UnderlyingCurrentValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDeliveryAmount = {"_p_FIX__UnderlyingDeliveryAmount", "FIX::UnderlyingDeliveryAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDetachmentPoint = {"_p_FIX__UnderlyingDetachmentPoint", "FIX::UnderlyingDetachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDirtyPrice = {"_p_FIX__UnderlyingDirtyPrice", "FIX::UnderlyingDirtyPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingEndPrice = {"_p_FIX__UnderlyingEndPrice", "FIX::UnderlyingEndPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingEndValue = {"_p_FIX__UnderlyingEndValue", "FIX::UnderlyingEndValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingExerciseStyle = {"_p_FIX__UnderlyingExerciseStyle", "FIX::UnderlyingExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFXRate = {"_p_FIX__UnderlyingFXRate", "FIX::UnderlyingFXRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFXRateCalc = {"_p_FIX__UnderlyingFXRateCalc", "FIX::UnderlyingFXRateCalc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFactor = {"_p_FIX__UnderlyingFactor", "FIX::UnderlyingFactor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFlowScheduleType = {"_p_FIX__UnderlyingFlowScheduleType", "FIX::UnderlyingFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIDSource = {"_p_FIX__UnderlyingIDSource", "FIX::UnderlyingIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrRegistry = {"_p_FIX__UnderlyingInstrRegistry", "FIX::UnderlyingInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyID = {"_p_FIX__UnderlyingInstrumentPartyID", "FIX::UnderlyingInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyIDSource = {"_p_FIX__UnderlyingInstrumentPartyIDSource", "FIX::UnderlyingInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyRole = {"_p_FIX__UnderlyingInstrumentPartyRole", "FIX::UnderlyingInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartySubID = {"_p_FIX__UnderlyingInstrumentPartySubID", "FIX::UnderlyingInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartySubIDType = {"_p_FIX__UnderlyingInstrumentPartySubIDType", "FIX::UnderlyingInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIssueDate = {"_p_FIX__UnderlyingIssueDate", "FIX::UnderlyingIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIssuer = {"_p_FIX__UnderlyingIssuer", "FIX::UnderlyingIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLastPx = {"_p_FIX__UnderlyingLastPx", "FIX::UnderlyingLastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLastQty = {"_p_FIX__UnderlyingLastQty", "FIX::UnderlyingLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegCFICode = {"_p_FIX__UnderlyingLegCFICode", "FIX::UnderlyingLegCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityDate = {"_p_FIX__UnderlyingLegMaturityDate", "FIX::UnderlyingLegMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityMonthYear = {"_p_FIX__UnderlyingLegMaturityMonthYear", "FIX::UnderlyingLegMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityTime = {"_p_FIX__UnderlyingLegMaturityTime", "FIX::UnderlyingLegMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegOptAttribute = {"_p_FIX__UnderlyingLegOptAttribute", "FIX::UnderlyingLegOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegPutOrCall = {"_p_FIX__UnderlyingLegPutOrCall", "FIX::UnderlyingLegPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityAltID = {"_p_FIX__UnderlyingLegSecurityAltID", "FIX::UnderlyingLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityAltIDSource = {"_p_FIX__UnderlyingLegSecurityAltIDSource", "FIX::UnderlyingLegSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityDesc = {"_p_FIX__UnderlyingLegSecurityDesc", "FIX::UnderlyingLegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityExchange = {"_p_FIX__UnderlyingLegSecurityExchange", "FIX::UnderlyingLegSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityID = {"_p_FIX__UnderlyingLegSecurityID", "FIX::UnderlyingLegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityIDSource = {"_p_FIX__UnderlyingLegSecurityIDSource", "FIX::UnderlyingLegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecuritySubType = {"_p_FIX__UnderlyingLegSecuritySubType", "FIX::UnderlyingLegSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityType = {"_p_FIX__UnderlyingLegSecurityType", "FIX::UnderlyingLegSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegStrikePrice = {"_p_FIX__UnderlyingLegStrikePrice", "FIX::UnderlyingLegStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSymbol = {"_p_FIX__UnderlyingLegSymbol", "FIX::UnderlyingLegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSymbolSfx = {"_p_FIX__UnderlyingLegSymbolSfx", "FIX::UnderlyingLegSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLocaleOfIssue = {"_p_FIX__UnderlyingLocaleOfIssue", "FIX::UnderlyingLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityDate = {"_p_FIX__UnderlyingMaturityDate", "FIX::UnderlyingMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityDay = {"_p_FIX__UnderlyingMaturityDay", "FIX::UnderlyingMaturityDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityMonthYear = {"_p_FIX__UnderlyingMaturityMonthYear", "FIX::UnderlyingMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityTime = {"_p_FIX__UnderlyingMaturityTime", "FIX::UnderlyingMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingNotionalPercentageOutstanding = {"_p_FIX__UnderlyingNotionalPercentageOutstanding", "FIX::UnderlyingNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingOptAttribute = {"_p_FIX__UnderlyingOptAttribute", "FIX::UnderlyingOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding = {"_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding", "FIX::UnderlyingOriginalNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPayAmount = {"_p_FIX__UnderlyingPayAmount", "FIX::UnderlyingPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceDeterminationMethod = {"_p_FIX__UnderlyingPriceDeterminationMethod", "FIX::UnderlyingPriceDeterminationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceUnitOfMeasure = {"_p_FIX__UnderlyingPriceUnitOfMeasure", "FIX::UnderlyingPriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty = {"_p_FIX__UnderlyingPriceUnitOfMeasureQty", "FIX::UnderlyingPriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingProduct = {"_p_FIX__UnderlyingProduct", "FIX::UnderlyingProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPutOrCall = {"_p_FIX__UnderlyingPutOrCall", "FIX::UnderlyingPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPx = {"_p_FIX__UnderlyingPx", "FIX::UnderlyingPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingQty = {"_p_FIX__UnderlyingQty", "FIX::UnderlyingQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRedemptionDate = {"_p_FIX__UnderlyingRedemptionDate", "FIX::UnderlyingRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepoCollateralSecurityType = {"_p_FIX__UnderlyingRepoCollateralSecurityType", "FIX::UnderlyingRepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepurchaseRate = {"_p_FIX__UnderlyingRepurchaseRate", "FIX::UnderlyingRepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepurchaseTerm = {"_p_FIX__UnderlyingRepurchaseTerm", "FIX::UnderlyingRepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRestructuringType = {"_p_FIX__UnderlyingRestructuringType", "FIX::UnderlyingRestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityAltID = {"_p_FIX__UnderlyingSecurityAltID", "FIX::UnderlyingSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityAltIDSource = {"_p_FIX__UnderlyingSecurityAltIDSource", "FIX::UnderlyingSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityDesc = {"_p_FIX__UnderlyingSecurityDesc", "FIX::UnderlyingSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityExchange = {"_p_FIX__UnderlyingSecurityExchange", "FIX::UnderlyingSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityID = {"_p_FIX__UnderlyingSecurityID", "FIX::UnderlyingSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityIDSource = {"_p_FIX__UnderlyingSecurityIDSource", "FIX::UnderlyingSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecuritySubType = {"_p_FIX__UnderlyingSecuritySubType", "FIX::UnderlyingSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityType = {"_p_FIX__UnderlyingSecurityType", "FIX::UnderlyingSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSeniority = {"_p_FIX__UnderlyingSeniority", "FIX::UnderlyingSeniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlMethod = {"_p_FIX__UnderlyingSettlMethod", "FIX::UnderlyingSettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlPrice = {"_p_FIX__UnderlyingSettlPrice", "FIX::UnderlyingSettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlPriceType = {"_p_FIX__UnderlyingSettlPriceType", "FIX::UnderlyingSettlPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementDate = {"_p_FIX__UnderlyingSettlementDate", "FIX::UnderlyingSettlementDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementStatus = {"_p_FIX__UnderlyingSettlementStatus", "FIX::UnderlyingSettlementStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementType = {"_p_FIX__UnderlyingSettlementType", "FIX::UnderlyingSettlementType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStartValue = {"_p_FIX__UnderlyingStartValue", "FIX::UnderlyingStartValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStateOrProvinceOfIssue = {"_p_FIX__UnderlyingStateOrProvinceOfIssue", "FIX::UnderlyingStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStipType = {"_p_FIX__UnderlyingStipType", "FIX::UnderlyingStipType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStipValue = {"_p_FIX__UnderlyingStipValue", "FIX::UnderlyingStipValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStrikeCurrency = {"_p_FIX__UnderlyingStrikeCurrency", "FIX::UnderlyingStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStrikePrice = {"_p_FIX__UnderlyingStrikePrice", "FIX::UnderlyingStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSymbol = {"_p_FIX__UnderlyingSymbol", "FIX::UnderlyingSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSymbolSfx = {"_p_FIX__UnderlyingSymbolSfx", "FIX::UnderlyingSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTimeUnit = {"_p_FIX__UnderlyingTimeUnit", "FIX::UnderlyingTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTradingSessionID = {"_p_FIX__UnderlyingTradingSessionID", "FIX::UnderlyingTradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTradingSessionSubID = {"_p_FIX__UnderlyingTradingSessionSubID", "FIX::UnderlyingTradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingUnitOfMeasure = {"_p_FIX__UnderlyingUnitOfMeasure", "FIX::UnderlyingUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingUnitOfMeasureQty = {"_p_FIX__UnderlyingUnitOfMeasureQty", "FIX::UnderlyingUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyID = {"_p_FIX__UndlyInstrumentPartyID", "FIX::UndlyInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyIDSource = {"_p_FIX__UndlyInstrumentPartyIDSource", "FIX::UndlyInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyRole = {"_p_FIX__UndlyInstrumentPartyRole", "FIX::UndlyInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartySubID = {"_p_FIX__UndlyInstrumentPartySubID", "FIX::UndlyInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartySubIDType = {"_p_FIX__UndlyInstrumentPartySubIDType", "FIX::UndlyInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnitOfMeasure = {"_p_FIX__UnitOfMeasure", "FIX::UnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnitOfMeasureQty = {"_p_FIX__UnitOfMeasureQty", "FIX::UnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsolicitedIndicator = {"_p_FIX__UnsolicitedIndicator", "FIX::UnsolicitedIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsupportedMessageType = {"_p_FIX__UnsupportedMessageType", "FIX::UnsupportedMessageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsupportedVersion = {"_p_FIX__UnsupportedVersion", "FIX::UnsupportedVersion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Urgency = {"_p_FIX__Urgency", "FIX::Urgency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserRequestID = {"_p_FIX__UserRequestID", "FIX::UserRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserRequestType = {"_p_FIX__UserRequestType", "FIX::UserRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserStatus = {"_p_FIX__UserStatus", "FIX::UserStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserStatusText = {"_p_FIX__UserStatusText", "FIX::UserStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Username = {"_p_FIX__Username", "FIX::Username *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcDateField = {"_p_FIX__UtcDateField", "FIX::UtcDateField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcTimeOnlyField = {"_p_FIX__UtcTimeOnlyField", "FIX::UtcTimeOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcTimeStampField = {"_p_FIX__UtcTimeStampField", "FIX::UtcTimeStampField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValidUntilTime = {"_p_FIX__ValidUntilTime", "FIX::ValidUntilTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValuationMethod = {"_p_FIX__ValuationMethod", "FIX::ValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValueOfFutures = {"_p_FIX__ValueOfFutures", "FIX::ValueOfFutures *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__VenueType = {"_p_FIX__VenueType", "FIX::VenueType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Volatility = {"_p_FIX__Volatility", "FIX::Volatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WaveNo = {"_p_FIX__WaveNo", "FIX::WaveNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WorkingIndicator = {"_p_FIX__WorkingIndicator", "FIX::WorkingIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WtAverageLiquidity = {"_p_FIX__WtAverageLiquidity", "FIX::WtAverageLiquidity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XMLDATA = {"_p_FIX__XMLDATA", "FIX::XMLDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XmlData = {"_p_FIX__XmlData", "FIX::XmlData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XmlDataLen = {"_p_FIX__XmlDataLen", "FIX::XmlDataLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Yield = {"_p_FIX__Yield", "FIX::Yield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldCalcDate = {"_p_FIX__YieldCalcDate", "FIX::YieldCalcDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionDate = {"_p_FIX__YieldRedemptionDate", "FIX::YieldRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionPrice = {"_p_FIX__YieldRedemptionPrice", "FIX::YieldRedemptionPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionPriceType = {"_p_FIX__YieldRedemptionPriceType", "FIX::YieldRedemptionPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldType = {"_p_FIX__YieldType", "FIX::YieldType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fields = {"_p_Fields", "Fields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Group = {"_p_Group", "Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Groups = {"_p_Groups", "Groups *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntArray = {"_p_IntArray", "IntArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntField = {"_p_IntField", "IntField *|SeqNumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Log = {"_p_Log", "Log *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LogFactory = {"_p_LogFactory", "LogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MessageStore = {"_p_MessageStore", "MessageStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MessageStoreFactory = {"_p_MessageStoreFactory", "MessageStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MsgType = {"_p_MsgType", "MsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mutex = {"_p_Mutex", "Mutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Responder = {"_p_Responder", "Responder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SessionID = {"_p_SessionID", "SessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StringField = {"_p_StringField", "StringField *|TzTimeStampField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeRange = {"_p_TimeRange", "TimeRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcDate = {"_p_UtcDate", "UtcDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcDateField = {"_p_UtcDateField", "UtcDateField *|UtcDateOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcTimeOnly = {"_p_UtcTimeOnly", "UtcTimeOnly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcTimeStamp = {"_p_UtcTimeStamp", "UtcTimeStamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_g_const_iterator = {"_p_g_const_iterator", "g_const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_g_iterator = {"_p_g_iterator", "g_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_message_order = {"_p_message_order", "message_order *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_FIX__DataDictionary = {"_p_p_FIX__DataDictionary", "FIX::DataDictionary **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setTFIX__SessionID_t = {"_p_std__setTFIX__SessionID_t", "std::set<FIX::SessionID > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string__size_type = {"_p_std__string__size_type", "std::string::size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorTstd__string_t = {"_p_std__vectorTstd__string_t", "std::vector<std::string > *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ApplVerID,
  &_swigt__p_Application,
  &_swigt__p_BeginString,
  &_swigt__p_DOMDocumentPtr,
  &_swigt__p_Data,
  &_swigt__p_DataDictionary,
  &_swigt__p_DataDictionaryProvider,
  &_swigt__p_DateTime,
  &_swigt__p_Dictionaries,
  &_swigt__p_DoubleField,
  &_swigt__p_FIX__AMT,
  &_swigt__p_FIX__Acceptor,
  &_swigt__p_FIX__Account,
  &_swigt__p_FIX__AccountType,
  &_swigt__p_FIX__AccruedInterestAmt,
  &_swigt__p_FIX__AccruedInterestRate,
  &_swigt__p_FIX__AcctIDSource,
  &_swigt__p_FIX__Adjustment,
  &_swigt__p_FIX__AdjustmentType,
  &_swigt__p_FIX__AdvId,
  &_swigt__p_FIX__AdvRefID,
  &_swigt__p_FIX__AdvSide,
  &_swigt__p_FIX__AdvTransType,
  &_swigt__p_FIX__AffectedOrderID,
  &_swigt__p_FIX__AffectedSecondaryOrderID,
  &_swigt__p_FIX__AffirmStatus,
  &_swigt__p_FIX__AggregatedBook,
  &_swigt__p_FIX__AggressorIndicator,
  &_swigt__p_FIX__AgreementCurrency,
  &_swigt__p_FIX__AgreementDate,
  &_swigt__p_FIX__AgreementDesc,
  &_swigt__p_FIX__AgreementID,
  &_swigt__p_FIX__AllocAccount,
  &_swigt__p_FIX__AllocAccountType,
  &_swigt__p_FIX__AllocAccruedInterestAmt,
  &_swigt__p_FIX__AllocAcctIDSource,
  &_swigt__p_FIX__AllocAvgPx,
  &_swigt__p_FIX__AllocCancReplaceReason,
  &_swigt__p_FIX__AllocClearingFeeIndicator,
  &_swigt__p_FIX__AllocCustomerCapacity,
  &_swigt__p_FIX__AllocHandlInst,
  &_swigt__p_FIX__AllocID,
  &_swigt__p_FIX__AllocInterestAtMaturity,
  &_swigt__p_FIX__AllocIntermedReqType,
  &_swigt__p_FIX__AllocLinkID,
  &_swigt__p_FIX__AllocLinkType,
  &_swigt__p_FIX__AllocMethod,
  &_swigt__p_FIX__AllocNetMoney,
  &_swigt__p_FIX__AllocNoOrdersType,
  &_swigt__p_FIX__AllocPositionEffect,
  &_swigt__p_FIX__AllocPrice,
  &_swigt__p_FIX__AllocQty,
  &_swigt__p_FIX__AllocRejCode,
  &_swigt__p_FIX__AllocReportID,
  &_swigt__p_FIX__AllocReportRefID,
  &_swigt__p_FIX__AllocReportType,
  &_swigt__p_FIX__AllocSettlCurrAmt,
  &_swigt__p_FIX__AllocSettlCurrency,
  &_swigt__p_FIX__AllocSettlInstType,
  &_swigt__p_FIX__AllocShares,
  &_swigt__p_FIX__AllocStatus,
  &_swigt__p_FIX__AllocText,
  &_swigt__p_FIX__AllocTransType,
  &_swigt__p_FIX__AllocType,
  &_swigt__p_FIX__AllowableOneSidednessCurr,
  &_swigt__p_FIX__AllowableOneSidednessPct,
  &_swigt__p_FIX__AllowableOneSidednessValue,
  &_swigt__p_FIX__AltMDSourceID,
  &_swigt__p_FIX__ApplBegSeqNum,
  &_swigt__p_FIX__ApplEndSeqNum,
  &_swigt__p_FIX__ApplExtID,
  &_swigt__p_FIX__ApplID,
  &_swigt__p_FIX__ApplLastSeqNum,
  &_swigt__p_FIX__ApplNewSeqNum,
  &_swigt__p_FIX__ApplQueueAction,
  &_swigt__p_FIX__ApplQueueDepth,
  &_swigt__p_FIX__ApplQueueMax,
  &_swigt__p_FIX__ApplQueueResolution,
  &_swigt__p_FIX__ApplReportID,
  &_swigt__p_FIX__ApplReportType,
  &_swigt__p_FIX__ApplReqID,
  &_swigt__p_FIX__ApplReqType,
  &_swigt__p_FIX__ApplResendFlag,
  &_swigt__p_FIX__ApplResponseError,
  &_swigt__p_FIX__ApplResponseID,
  &_swigt__p_FIX__ApplResponseType,
  &_swigt__p_FIX__ApplSeqNum,
  &_swigt__p_FIX__ApplTotalMessageCount,
  &_swigt__p_FIX__ApplVerID,
  &_swigt__p_FIX__Application,
  &_swigt__p_FIX__AsOfIndicator,
  &_swigt__p_FIX__AsgnReqID,
  &_swigt__p_FIX__AsgnRptID,
  &_swigt__p_FIX__AssignmentMethod,
  &_swigt__p_FIX__AssignmentUnit,
  &_swigt__p_FIX__AttachmentPoint,
  &_swigt__p_FIX__AutoAcceptIndicator,
  &_swigt__p_FIX__AvgParPx,
  &_swigt__p_FIX__AvgPrxPrecision,
  &_swigt__p_FIX__AvgPx,
  &_swigt__p_FIX__AvgPxIndicator,
  &_swigt__p_FIX__AvgPxPrecision,
  &_swigt__p_FIX__BOOLEAN,
  &_swigt__p_FIX__BasisFeatureDate,
  &_swigt__p_FIX__BasisFeaturePrice,
  &_swigt__p_FIX__BasisPxType,
  &_swigt__p_FIX__BeginSeqNo,
  &_swigt__p_FIX__BeginString,
  &_swigt__p_FIX__Benchmark,
  &_swigt__p_FIX__BenchmarkCurveCurrency,
  &_swigt__p_FIX__BenchmarkCurveName,
  &_swigt__p_FIX__BenchmarkCurvePoint,
  &_swigt__p_FIX__BenchmarkPrice,
  &_swigt__p_FIX__BenchmarkPriceType,
  &_swigt__p_FIX__BenchmarkSecurityID,
  &_swigt__p_FIX__BenchmarkSecurityIDSource,
  &_swigt__p_FIX__BidDescriptor,
  &_swigt__p_FIX__BidDescriptorType,
  &_swigt__p_FIX__BidForwardPoints,
  &_swigt__p_FIX__BidForwardPoints2,
  &_swigt__p_FIX__BidID,
  &_swigt__p_FIX__BidPx,
  &_swigt__p_FIX__BidRequestTransType,
  &_swigt__p_FIX__BidSize,
  &_swigt__p_FIX__BidSpotRate,
  &_swigt__p_FIX__BidSwapPoints,
  &_swigt__p_FIX__BidTradeType,
  &_swigt__p_FIX__BidType,
  &_swigt__p_FIX__BidYield,
  &_swigt__p_FIX__BodyLength,
  &_swigt__p_FIX__BookingRefID,
  &_swigt__p_FIX__BookingType,
  &_swigt__p_FIX__BookingUnit,
  &_swigt__p_FIX__BoolField,
  &_swigt__p_FIX__BrokerOfCredit,
  &_swigt__p_FIX__BusinessRejectReason,
  &_swigt__p_FIX__BusinessRejectRefID,
  &_swigt__p_FIX__BuyVolume,
  &_swigt__p_FIX__CFICode,
  &_swigt__p_FIX__CHAR,
  &_swigt__p_FIX__COUNTRY,
  &_swigt__p_FIX__CPProgram,
  &_swigt__p_FIX__CPRegType,
  &_swigt__p_FIX__CURRENCY,
  &_swigt__p_FIX__CalculatedCcyLastQty,
  &_swigt__p_FIX__CancellationRights,
  &_swigt__p_FIX__CapPrice,
  &_swigt__p_FIX__CardExpDate,
  &_swigt__p_FIX__CardHolderName,
  &_swigt__p_FIX__CardIssNo,
  &_swigt__p_FIX__CardIssNum,
  &_swigt__p_FIX__CardNumber,
  &_swigt__p_FIX__CardStartDate,
  &_swigt__p_FIX__CashDistribAgentAcctName,
  &_swigt__p_FIX__CashDistribAgentAcctNumber,
  &_swigt__p_FIX__CashDistribAgentCode,
  &_swigt__p_FIX__CashDistribAgentName,
  &_swigt__p_FIX__CashDistribCurr,
  &_swigt__p_FIX__CashDistribPayRef,
  &_swigt__p_FIX__CashMargin,
  &_swigt__p_FIX__CashOrderQty,
  &_swigt__p_FIX__CashOutstanding,
  &_swigt__p_FIX__CashSettlAgentAcctName,
  &_swigt__p_FIX__CashSettlAgentAcctNum,
  &_swigt__p_FIX__CashSettlAgentCode,
  &_swigt__p_FIX__CashSettlAgentContactName,
  &_swigt__p_FIX__CashSettlAgentContactPhone,
  &_swigt__p_FIX__CashSettlAgentName,
  &_swigt__p_FIX__CcyAmt,
  &_swigt__p_FIX__CharField,
  &_swigt__p_FIX__CheckSum,
  &_swigt__p_FIX__CheckSumField,
  &_swigt__p_FIX__ClOrdID,
  &_swigt__p_FIX__ClOrdLinkID,
  &_swigt__p_FIX__ClearingAccount,
  &_swigt__p_FIX__ClearingBusinessDate,
  &_swigt__p_FIX__ClearingFeeIndicator,
  &_swigt__p_FIX__ClearingFirm,
  &_swigt__p_FIX__ClearingInstruction,
  &_swigt__p_FIX__ClientBidID,
  &_swigt__p_FIX__ClientID,
  &_swigt__p_FIX__CollAction,
  &_swigt__p_FIX__CollApplType,
  &_swigt__p_FIX__CollAsgnID,
  &_swigt__p_FIX__CollAsgnReason,
  &_swigt__p_FIX__CollAsgnRefID,
  &_swigt__p_FIX__CollAsgnRejectReason,
  &_swigt__p_FIX__CollAsgnRespType,
  &_swigt__p_FIX__CollAsgnTransType,
  &_swigt__p_FIX__CollInquiryID,
  &_swigt__p_FIX__CollInquiryQualifier,
  &_swigt__p_FIX__CollInquiryResult,
  &_swigt__p_FIX__CollInquiryStatus,
  &_swigt__p_FIX__CollReqID,
  &_swigt__p_FIX__CollRespID,
  &_swigt__p_FIX__CollRptID,
  &_swigt__p_FIX__CollStatus,
  &_swigt__p_FIX__CommCurrency,
  &_swigt__p_FIX__CommType,
  &_swigt__p_FIX__Commission,
  &_swigt__p_FIX__ComplexEventCondition,
  &_swigt__p_FIX__ComplexEventEndDate,
  &_swigt__p_FIX__ComplexEventEndTime,
  &_swigt__p_FIX__ComplexEventPrice,
  &_swigt__p_FIX__ComplexEventPriceBoundaryMethod,
  &_swigt__p_FIX__ComplexEventPriceBoundaryPrecision,
  &_swigt__p_FIX__ComplexEventPriceTimeType,
  &_swigt__p_FIX__ComplexEventStartDate,
  &_swigt__p_FIX__ComplexEventStartTime,
  &_swigt__p_FIX__ComplexEventType,
  &_swigt__p_FIX__ComplexOptPayoutAmount,
  &_swigt__p_FIX__ComplianceID,
  &_swigt__p_FIX__Concession,
  &_swigt__p_FIX__ConfigError,
  &_swigt__p_FIX__ConfirmID,
  &_swigt__p_FIX__ConfirmRefID,
  &_swigt__p_FIX__ConfirmRejReason,
  &_swigt__p_FIX__ConfirmReqID,
  &_swigt__p_FIX__ConfirmStatus,
  &_swigt__p_FIX__ConfirmTransType,
  &_swigt__p_FIX__ConfirmType,
  &_swigt__p_FIX__ContAmtCurr,
  &_swigt__p_FIX__ContAmtType,
  &_swigt__p_FIX__ContAmtValue,
  &_swigt__p_FIX__ContIntRptID,
  &_swigt__p_FIX__ContextPartyID,
  &_swigt__p_FIX__ContextPartyIDSource,
  &_swigt__p_FIX__ContextPartyRole,
  &_swigt__p_FIX__ContextPartySubID,
  &_swigt__p_FIX__ContextPartySubIDType,
  &_swigt__p_FIX__ContingencyType,
  &_swigt__p_FIX__ContraBroker,
  &_swigt__p_FIX__ContraLegRefID,
  &_swigt__p_FIX__ContraTradeQty,
  &_swigt__p_FIX__ContraTradeTime,
  &_swigt__p_FIX__ContraTrader,
  &_swigt__p_FIX__ContractMultiplier,
  &_swigt__p_FIX__ContractMultiplierUnit,
  &_swigt__p_FIX__ContractSettlMonth,
  &_swigt__p_FIX__ContraryInstructionIndicator,
  &_swigt__p_FIX__CopyMsgIndicator,
  &_swigt__p_FIX__CorporateAction,
  &_swigt__p_FIX__Country,
  &_swigt__p_FIX__CountryOfIssue,
  &_swigt__p_FIX__CouponPaymentDate,
  &_swigt__p_FIX__CouponRate,
  &_swigt__p_FIX__CoveredOrUncovered,
  &_swigt__p_FIX__CreditRating,
  &_swigt__p_FIX__CrossID,
  &_swigt__p_FIX__CrossPercent,
  &_swigt__p_FIX__CrossPrioritization,
  &_swigt__p_FIX__CrossType,
  &_swigt__p_FIX__CstmApplVerID,
  &_swigt__p_FIX__CumQty,
  &_swigt__p_FIX__Currency,
  &_swigt__p_FIX__CurrencyRatio,
  &_swigt__p_FIX__CustDirectedOrder,
  &_swigt__p_FIX__CustOrderCapacity,
  &_swigt__p_FIX__CustOrderHandlingInst,
  &_swigt__p_FIX__CustomerOrFirm,
  &_swigt__p_FIX__CxlQty,
  &_swigt__p_FIX__CxlRejReason,
  &_swigt__p_FIX__CxlRejResponseTo,
  &_swigt__p_FIX__CxlType,
  &_swigt__p_FIX__DATA,
  &_swigt__p_FIX__DAYOFMONTH,
  &_swigt__p_FIX__DKReason,
  &_swigt__p_FIX__DataDictionary,
  &_swigt__p_FIX__DataDictionaryNotFound,
  &_swigt__p_FIX__DateOfBirth,
  &_swigt__p_FIX__DatedDate,
  &_swigt__p_FIX__DayAvgPx,
  &_swigt__p_FIX__DayBookingInst,
  &_swigt__p_FIX__DayCumQty,
  &_swigt__p_FIX__DayOrderQty,
  &_swigt__p_FIX__DealingCapacity,
  &_swigt__p_FIX__DefBidSize,
  &_swigt__p_FIX__DefOfferSize,
  &_swigt__p_FIX__DefaultApplExtID,
  &_swigt__p_FIX__DefaultApplVerID,
  &_swigt__p_FIX__DefaultCstmApplVerID,
  &_swigt__p_FIX__DefaultVerIndicator,
  &_swigt__p_FIX__DeleteReason,
  &_swigt__p_FIX__DeliverToCompID,
  &_swigt__p_FIX__DeliverToLocationID,
  &_swigt__p_FIX__DeliverToSubID,
  &_swigt__p_FIX__DeliveryDate,
  &_swigt__p_FIX__DeliveryForm,
  &_swigt__p_FIX__DeliveryType,
  &_swigt__p_FIX__DerivFlexProductEligibilityIndicator,
  &_swigt__p_FIX__DerivativeCFICode,
  &_swigt__p_FIX__DerivativeCapPrice,
  &_swigt__p_FIX__DerivativeContractMultiplier,
  &_swigt__p_FIX__DerivativeContractMultiplierUnit,
  &_swigt__p_FIX__DerivativeContractSettlMonth,
  &_swigt__p_FIX__DerivativeCountryOfIssue,
  &_swigt__p_FIX__DerivativeEncodedIssuer,
  &_swigt__p_FIX__DerivativeEncodedIssuerLen,
  &_swigt__p_FIX__DerivativeEncodedSecurityDesc,
  &_swigt__p_FIX__DerivativeEncodedSecurityDescLen,
  &_swigt__p_FIX__DerivativeEventDate,
  &_swigt__p_FIX__DerivativeEventPx,
  &_swigt__p_FIX__DerivativeEventText,
  &_swigt__p_FIX__DerivativeEventTime,
  &_swigt__p_FIX__DerivativeEventType,
  &_swigt__p_FIX__DerivativeExerciseStyle,
  &_swigt__p_FIX__DerivativeFloorPrice,
  &_swigt__p_FIX__DerivativeFlowScheduleType,
  &_swigt__p_FIX__DerivativeFuturesValuationMethod,
  &_swigt__p_FIX__DerivativeInstrAttribType,
  &_swigt__p_FIX__DerivativeInstrAttribValue,
  &_swigt__p_FIX__DerivativeInstrRegistry,
  &_swigt__p_FIX__DerivativeInstrmtAssignmentMethod,
  &_swigt__p_FIX__DerivativeInstrumentPartyID,
  &_swigt__p_FIX__DerivativeInstrumentPartyIDSource,
  &_swigt__p_FIX__DerivativeInstrumentPartyRole,
  &_swigt__p_FIX__DerivativeInstrumentPartySubID,
  &_swigt__p_FIX__DerivativeInstrumentPartySubIDType,
  &_swigt__p_FIX__DerivativeIssueDate,
  &_swigt__p_FIX__DerivativeIssuer,
  &_swigt__p_FIX__DerivativeListMethod,
  &_swigt__p_FIX__DerivativeLocaleOfIssue,
  &_swigt__p_FIX__DerivativeMaturityDate,
  &_swigt__p_FIX__DerivativeMaturityMonthYear,
  &_swigt__p_FIX__DerivativeMaturityTime,
  &_swigt__p_FIX__DerivativeMinPriceIncrement,
  &_swigt__p_FIX__DerivativeMinPriceIncrementAmount,
  &_swigt__p_FIX__DerivativeNTPositionLimit,
  &_swigt__p_FIX__DerivativeOptAttribute,
  &_swigt__p_FIX__DerivativeOptPayAmount,
  &_swigt__p_FIX__DerivativePositionLimit,
  &_swigt__p_FIX__DerivativePriceQuoteMethod,
  &_swigt__p_FIX__DerivativePriceUnitOfMeasure,
  &_swigt__p_FIX__DerivativePriceUnitOfMeasureQty,
  &_swigt__p_FIX__DerivativeProduct,
  &_swigt__p_FIX__DerivativeProductComplex,
  &_swigt__p_FIX__DerivativePutOrCall,
  &_swigt__p_FIX__DerivativeSecurityAltID,
  &_swigt__p_FIX__DerivativeSecurityAltIDSource,
  &_swigt__p_FIX__DerivativeSecurityDesc,
  &_swigt__p_FIX__DerivativeSecurityExchange,
  &_swigt__p_FIX__DerivativeSecurityGroup,
  &_swigt__p_FIX__DerivativeSecurityID,
  &_swigt__p_FIX__DerivativeSecurityIDSource,
  &_swigt__p_FIX__DerivativeSecurityListRequestType,
  &_swigt__p_FIX__DerivativeSecurityStatus,
  &_swigt__p_FIX__DerivativeSecuritySubType,
  &_swigt__p_FIX__DerivativeSecurityType,
  &_swigt__p_FIX__DerivativeSecurityXML,
  &_swigt__p_FIX__DerivativeSecurityXMLLen,
  &_swigt__p_FIX__DerivativeSecurityXMLSchema,
  &_swigt__p_FIX__DerivativeSettlMethod,
  &_swigt__p_FIX__DerivativeSettleOnOpenFlag,
  &_swigt__p_FIX__DerivativeStateOrProvinceOfIssue,
  &_swigt__p_FIX__DerivativeStrikeCurrency,
  &_swigt__p_FIX__DerivativeStrikeMultiplier,
  &_swigt__p_FIX__DerivativeStrikePrice,
  &_swigt__p_FIX__DerivativeStrikeValue,
  &_swigt__p_FIX__DerivativeSymbol,
  &_swigt__p_FIX__DerivativeSymbolSfx,
  &_swigt__p_FIX__DerivativeTimeUnit,
  &_swigt__p_FIX__DerivativeUnitOfMeasure,
  &_swigt__p_FIX__DerivativeUnitOfMeasureQty,
  &_swigt__p_FIX__DerivativeValuationMethod,
  &_swigt__p_FIX__Designation,
  &_swigt__p_FIX__DeskID,
  &_swigt__p_FIX__DeskOrderHandlingInst,
  &_swigt__p_FIX__DeskType,
  &_swigt__p_FIX__DeskTypeSource,
  &_swigt__p_FIX__DetachmentPoint,
  &_swigt__p_FIX__Dictionary,
  &_swigt__p_FIX__Dictionary__Data__const_iterator,
  &_swigt__p_FIX__DiscretionInst,
  &_swigt__p_FIX__DiscretionLimitType,
  &_swigt__p_FIX__DiscretionMoveType,
  &_swigt__p_FIX__DiscretionOffset,
  &_swigt__p_FIX__DiscretionOffsetType,
  &_swigt__p_FIX__DiscretionOffsetValue,
  &_swigt__p_FIX__DiscretionPrice,
  &_swigt__p_FIX__DiscretionRoundDirection,
  &_swigt__p_FIX__DiscretionScope,
  &_swigt__p_FIX__DisplayHighQty,
  &_swigt__p_FIX__DisplayLowQty,
  &_swigt__p_FIX__DisplayMethod,
  &_swigt__p_FIX__DisplayMinIncr,
  &_swigt__p_FIX__DisplayQty,
  &_swigt__p_FIX__DisplayWhen,
  &_swigt__p_FIX__DistribPaymentMethod,
  &_swigt__p_FIX__DistribPercentage,
  &_swigt__p_FIX__DividendYield,
  &_swigt__p_FIX__DlvyInst,
  &_swigt__p_FIX__DlvyInstType,
  &_swigt__p_FIX__DoNotSend,
  &_swigt__p_FIX__DoubleField,
  &_swigt__p_FIX__DueToRelated,
  &_swigt__p_FIX__DuplicateFieldNumber,
  &_swigt__p_FIX__EFPTrackingError,
  &_swigt__p_FIX__EXCHANGE,
  &_swigt__p_FIX__EffectiveTime,
  &_swigt__p_FIX__EmailThreadID,
  &_swigt__p_FIX__EmailType,
  &_swigt__p_FIX__EncodedAllocText,
  &_swigt__p_FIX__EncodedAllocTextLen,
  &_swigt__p_FIX__EncodedHeadline,
  &_swigt__p_FIX__EncodedHeadlineLen,
  &_swigt__p_FIX__EncodedIssuer,
  &_swigt__p_FIX__EncodedIssuerLen,
  &_swigt__p_FIX__EncodedLegIssuer,
  &_swigt__p_FIX__EncodedLegIssuerLen,
  &_swigt__p_FIX__EncodedLegSecurityDesc,
  &_swigt__p_FIX__EncodedLegSecurityDescLen,
  &_swigt__p_FIX__EncodedListExecInst,
  &_swigt__p_FIX__EncodedListExecInstLen,
  &_swigt__p_FIX__EncodedListStatusText,
  &_swigt__p_FIX__EncodedListStatusTextLen,
  &_swigt__p_FIX__EncodedMktSegmDesc,
  &_swigt__p_FIX__EncodedMktSegmDescLen,
  &_swigt__p_FIX__EncodedSecurityDesc,
  &_swigt__p_FIX__EncodedSecurityDescLen,
  &_swigt__p_FIX__EncodedSecurityListDesc,
  &_swigt__p_FIX__EncodedSecurityListDescLen,
  &_swigt__p_FIX__EncodedSubject,
  &_swigt__p_FIX__EncodedSubjectLen,
  &_swigt__p_FIX__EncodedSymbol,
  &_swigt__p_FIX__EncodedSymbolLen,
  &_swigt__p_FIX__EncodedText,
  &_swigt__p_FIX__EncodedTextLen,
  &_swigt__p_FIX__EncodedUnderlyingIssuer,
  &_swigt__p_FIX__EncodedUnderlyingIssuerLen,
  &_swigt__p_FIX__EncodedUnderlyingSecurityDesc,
  &_swigt__p_FIX__EncodedUnderlyingSecurityDescLen,
  &_swigt__p_FIX__EncryptMethod,
  &_swigt__p_FIX__EncryptedNewPassword,
  &_swigt__p_FIX__EncryptedNewPasswordLen,
  &_swigt__p_FIX__EncryptedPassword,
  &_swigt__p_FIX__EncryptedPasswordLen,
  &_swigt__p_FIX__EncryptedPasswordMethod,
  &_swigt__p_FIX__EndAccruedInterestAmt,
  &_swigt__p_FIX__EndCash,
  &_swigt__p_FIX__EndDate,
  &_swigt__p_FIX__EndMaturityMonthYear,
  &_swigt__p_FIX__EndSeqNo,
  &_swigt__p_FIX__EndStrikePxRange,
  &_swigt__p_FIX__EndTickPriceRange,
  &_swigt__p_FIX__EventDate,
  &_swigt__p_FIX__EventPx,
  &_swigt__p_FIX__EventText,
  &_swigt__p_FIX__EventTime,
  &_swigt__p_FIX__EventType,
  &_swigt__p_FIX__ExDate,
  &_swigt__p_FIX__ExDestination,
  &_swigt__p_FIX__ExDestinationIDSource,
  &_swigt__p_FIX__Exception,
  &_swigt__p_FIX__ExchangeForPhysical,
  &_swigt__p_FIX__ExchangeRule,
  &_swigt__p_FIX__ExchangeSpecialInstructions,
  &_swigt__p_FIX__ExecAckStatus,
  &_swigt__p_FIX__ExecBroker,
  &_swigt__p_FIX__ExecID,
  &_swigt__p_FIX__ExecInst,
  &_swigt__p_FIX__ExecInstValue,
  &_swigt__p_FIX__ExecPriceAdjustment,
  &_swigt__p_FIX__ExecPriceType,
  &_swigt__p_FIX__ExecRefID,
  &_swigt__p_FIX__ExecRestatementReason,
  &_swigt__p_FIX__ExecTransType,
  &_swigt__p_FIX__ExecType,
  &_swigt__p_FIX__ExecValuationPoint,
  &_swigt__p_FIX__ExerciseMethod,
  &_swigt__p_FIX__ExerciseStyle,
  &_swigt__p_FIX__ExpQty,
  &_swigt__p_FIX__ExpType,
  &_swigt__p_FIX__ExpirationCycle,
  &_swigt__p_FIX__ExpirationQtyType,
  &_swigt__p_FIX__ExpireDate,
  &_swigt__p_FIX__ExpireTime,
  &_swigt__p_FIX__FLOAT,
  &_swigt__p_FIX__Factor,
  &_swigt__p_FIX__FairValue,
  &_swigt__p_FIX__FeeMultiplier,
  &_swigt__p_FIX__FieldBase,
  &_swigt__p_FIX__FieldConvertError,
  &_swigt__p_FIX__FieldMap,
  &_swigt__p_FIX__FieldMap__Fields__const_iterator,
  &_swigt__p_FIX__FieldMap__Groups__const_iterator,
  &_swigt__p_FIX__FieldNotFound,
  &_swigt__p_FIX__FileLog,
  &_swigt__p_FIX__FileLogFactory,
  &_swigt__p_FIX__FileStore,
  &_swigt__p_FIX__FileStoreFactory,
  &_swigt__p_FIX__FillExecID,
  &_swigt__p_FIX__FillLiquidityInd,
  &_swigt__p_FIX__FillPx,
  &_swigt__p_FIX__FillQty,
  &_swigt__p_FIX__FinancialStatus,
  &_swigt__p_FIX__FirmTradeID,
  &_swigt__p_FIX__FirstPx,
  &_swigt__p_FIX__FlexProductEligibilityIndicator,
  &_swigt__p_FIX__FlexibleIndicator,
  &_swigt__p_FIX__FloorPrice,
  &_swigt__p_FIX__FlowScheduleType,
  &_swigt__p_FIX__ForexReq,
  &_swigt__p_FIX__FundRenewWaiv,
  &_swigt__p_FIX__FutSettDate,
  &_swigt__p_FIX__FutSettDate2,
  &_swigt__p_FIX__FuturesValuationMethod,
  &_swigt__p_FIX__GTBookingInst,
  &_swigt__p_FIX__GapFillFlag,
  &_swigt__p_FIX__GrossTradeAmt,
  &_swigt__p_FIX__Group,
  &_swigt__p_FIX__HaltReasonChar,
  &_swigt__p_FIX__HaltReasonInt,
  &_swigt__p_FIX__HandlInst,
  &_swigt__p_FIX__Headline,
  &_swigt__p_FIX__HeartBtInt,
  &_swigt__p_FIX__HighLimitPrice,
  &_swigt__p_FIX__HighPx,
  &_swigt__p_FIX__HopCompID,
  &_swigt__p_FIX__HopRefID,
  &_swigt__p_FIX__HopSendingTime,
  &_swigt__p_FIX__HostCrossID,
  &_swigt__p_FIX__IDSource,
  &_swigt__p_FIX__INT,
  &_swigt__p_FIX__IOException,
  &_swigt__p_FIX__IOIID,
  &_swigt__p_FIX__IOINaturalFlag,
  &_swigt__p_FIX__IOIOthSvc,
  &_swigt__p_FIX__IOIQltyInd,
  &_swigt__p_FIX__IOIQty,
  &_swigt__p_FIX__IOIQualifier,
  &_swigt__p_FIX__IOIRefID,
  &_swigt__p_FIX__IOIShares,
  &_swigt__p_FIX__IOITransType,
  &_swigt__p_FIX__IOIid,
  &_swigt__p_FIX__ImpliedMarketIndicator,
  &_swigt__p_FIX__InViewOfCommon,
  &_swigt__p_FIX__IncTaxInd,
  &_swigt__p_FIX__IncorrectDataFormat,
  &_swigt__p_FIX__IncorrectMessageStructure,
  &_swigt__p_FIX__IncorrectTagValue,
  &_swigt__p_FIX__IndividualAllocID,
  &_swigt__p_FIX__IndividualAllocRejCode,
  &_swigt__p_FIX__IndividualAllocType,
  &_swigt__p_FIX__Initiator,
  &_swigt__p_FIX__InputSource,
  &_swigt__p_FIX__InstrAttribType,
  &_swigt__p_FIX__InstrAttribValue,
  &_swigt__p_FIX__InstrRegistry,
  &_swigt__p_FIX__InstrmtAssignmentMethod,
  &_swigt__p_FIX__InstrumentPartyID,
  &_swigt__p_FIX__InstrumentPartyIDSource,
  &_swigt__p_FIX__InstrumentPartyRole,
  &_swigt__p_FIX__InstrumentPartySubID,
  &_swigt__p_FIX__InstrumentPartySubIDType,
  &_swigt__p_FIX__IntField,
  &_swigt__p_FIX__InterestAccrualDate,
  &_swigt__p_FIX__InterestAtMaturity,
  &_swigt__p_FIX__InvalidMessage,
  &_swigt__p_FIX__InvalidMessageType,
  &_swigt__p_FIX__InvalidTagNumber,
  &_swigt__p_FIX__InvestorCountryOfResidence,
  &_swigt__p_FIX__IssueDate,
  &_swigt__p_FIX__Issuer,
  &_swigt__p_FIX__LANGUAGE,
  &_swigt__p_FIX__LENGTH,
  &_swigt__p_FIX__LOCALMKTDATE,
  &_swigt__p_FIX__LanguageCode,
  &_swigt__p_FIX__LastCapacity,
  &_swigt__p_FIX__LastForwardPoints,
  &_swigt__p_FIX__LastForwardPoints2,
  &_swigt__p_FIX__LastFragment,
  &_swigt__p_FIX__LastLiquidityInd,
  &_swigt__p_FIX__LastMkt,
  &_swigt__p_FIX__LastMsgSeqNumProcessed,
  &_swigt__p_FIX__LastNetworkResponseID,
  &_swigt__p_FIX__LastParPx,
  &_swigt__p_FIX__LastPx,
  &_swigt__p_FIX__LastQty,
  &_swigt__p_FIX__LastRptRequested,
  &_swigt__p_FIX__LastShares,
  &_swigt__p_FIX__LastSpotRate,
  &_swigt__p_FIX__LastSwapPoints,
  &_swigt__p_FIX__LastUpdateTime,
  &_swigt__p_FIX__LateIndicator,
  &_swigt__p_FIX__LeavesQty,
  &_swigt__p_FIX__LegAllocAccount,
  &_swigt__p_FIX__LegAllocAcctIDSource,
  &_swigt__p_FIX__LegAllocID,
  &_swigt__p_FIX__LegAllocQty,
  &_swigt__p_FIX__LegAllocSettlCurrency,
  &_swigt__p_FIX__LegBenchmarkCurveCurrency,
  &_swigt__p_FIX__LegBenchmarkCurveName,
  &_swigt__p_FIX__LegBenchmarkCurvePoint,
  &_swigt__p_FIX__LegBenchmarkPrice,
  &_swigt__p_FIX__LegBenchmarkPriceType,
  &_swigt__p_FIX__LegBidForwardPoints,
  &_swigt__p_FIX__LegBidPx,
  &_swigt__p_FIX__LegCFICode,
  &_swigt__p_FIX__LegCalculatedCcyLastQty,
  &_swigt__p_FIX__LegContractMultiplier,
  &_swigt__p_FIX__LegContractMultiplierUnit,
  &_swigt__p_FIX__LegContractSettlMonth,
  &_swigt__p_FIX__LegCountryOfIssue,
  &_swigt__p_FIX__LegCouponPaymentDate,
  &_swigt__p_FIX__LegCouponRate,
  &_swigt__p_FIX__LegCoveredOrUncovered,
  &_swigt__p_FIX__LegCreditRating,
  &_swigt__p_FIX__LegCurrency,
  &_swigt__p_FIX__LegCurrencyRatio,
  &_swigt__p_FIX__LegDatedDate,
  &_swigt__p_FIX__LegDividendYield,
  &_swigt__p_FIX__LegExecInst,
  &_swigt__p_FIX__LegExerciseStyle,
  &_swigt__p_FIX__LegFactor,
  &_swigt__p_FIX__LegFlowScheduleType,
  &_swigt__p_FIX__LegFutSettDate,
  &_swigt__p_FIX__LegGrossTradeAmt,
  &_swigt__p_FIX__LegIOIQty,
  &_swigt__p_FIX__LegIndividualAllocID,
  &_swigt__p_FIX__LegInstrRegistry,
  &_swigt__p_FIX__LegInterestAccrualDate,
  &_swigt__p_FIX__LegIssueDate,
  &_swigt__p_FIX__LegIssuer,
  &_swigt__p_FIX__LegLastForwardPoints,
  &_swigt__p_FIX__LegLastPx,
  &_swigt__p_FIX__LegLastQty,
  &_swigt__p_FIX__LegLocaleOfIssue,
  &_swigt__p_FIX__LegMaturityDate,
  &_swigt__p_FIX__LegMaturityMonthYear,
  &_swigt__p_FIX__LegMaturityTime,
  &_swigt__p_FIX__LegNumber,
  &_swigt__p_FIX__LegOfferForwardPoints,
  &_swigt__p_FIX__LegOfferPx,
  &_swigt__p_FIX__LegOptAttribute,
  &_swigt__p_FIX__LegOptionRatio,
  &_swigt__p_FIX__LegOrderQty,
  &_swigt__p_FIX__LegPool,
  &_swigt__p_FIX__LegPositionEffect,
  &_swigt__p_FIX__LegPrice,
  &_swigt__p_FIX__LegPriceType,
  &_swigt__p_FIX__LegPriceUnitOfMeasure,
  &_swigt__p_FIX__LegPriceUnitOfMeasureQty,
  &_swigt__p_FIX__LegProduct,
  &_swigt__p_FIX__LegPutOrCall,
  &_swigt__p_FIX__LegQty,
  &_swigt__p_FIX__LegRatioQty,
  &_swigt__p_FIX__LegRedemptionDate,
  &_swigt__p_FIX__LegRefID,
  &_swigt__p_FIX__LegRepoCollateralSecurityType,
  &_swigt__p_FIX__LegReportID,
  &_swigt__p_FIX__LegRepurchaseRate,
  &_swigt__p_FIX__LegRepurchaseTerm,
  &_swigt__p_FIX__LegSecurityAltID,
  &_swigt__p_FIX__LegSecurityAltIDSource,
  &_swigt__p_FIX__LegSecurityDesc,
  &_swigt__p_FIX__LegSecurityExchange,
  &_swigt__p_FIX__LegSecurityID,
  &_swigt__p_FIX__LegSecurityIDSource,
  &_swigt__p_FIX__LegSecuritySubType,
  &_swigt__p_FIX__LegSecurityType,
  &_swigt__p_FIX__LegSettlCurrency,
  &_swigt__p_FIX__LegSettlDate,
  &_swigt__p_FIX__LegSettlType,
  &_swigt__p_FIX__LegSettlmntTyp,
  &_swigt__p_FIX__LegSide,
  &_swigt__p_FIX__LegStateOrProvinceOfIssue,
  &_swigt__p_FIX__LegStipulationType,
  &_swigt__p_FIX__LegStipulationValue,
  &_swigt__p_FIX__LegStrikeCurrency,
  &_swigt__p_FIX__LegStrikePrice,
  &_swigt__p_FIX__LegSwapType,
  &_swigt__p_FIX__LegSymbol,
  &_swigt__p_FIX__LegSymbolSfx,
  &_swigt__p_FIX__LegTimeUnit,
  &_swigt__p_FIX__LegUnitOfMeasure,
  &_swigt__p_FIX__LegUnitOfMeasureQty,
  &_swigt__p_FIX__LegVolatility,
  &_swigt__p_FIX__LegalConfirm,
  &_swigt__p_FIX__LinesOfText,
  &_swigt__p_FIX__LiquidityIndType,
  &_swigt__p_FIX__LiquidityNumSecurities,
  &_swigt__p_FIX__LiquidityPctHigh,
  &_swigt__p_FIX__LiquidityPctLow,
  &_swigt__p_FIX__LiquidityValue,
  &_swigt__p_FIX__ListExecInst,
  &_swigt__p_FIX__ListExecInstType,
  &_swigt__p_FIX__ListID,
  &_swigt__p_FIX__ListMethod,
  &_swigt__p_FIX__ListName,
  &_swigt__p_FIX__ListNoOrds,
  &_swigt__p_FIX__ListOrderStatus,
  &_swigt__p_FIX__ListRejectReason,
  &_swigt__p_FIX__ListSeqNo,
  &_swigt__p_FIX__ListStatusText,
  &_swigt__p_FIX__ListStatusType,
  &_swigt__p_FIX__ListUpdateAction,
  &_swigt__p_FIX__LocaleOfIssue,
  &_swigt__p_FIX__LocateReqd,
  &_swigt__p_FIX__LocationID,
  &_swigt__p_FIX__Log,
  &_swigt__p_FIX__LogFactory,
  &_swigt__p_FIX__LongQty,
  &_swigt__p_FIX__LotType,
  &_swigt__p_FIX__LowLimitPrice,
  &_swigt__p_FIX__LowPx,
  &_swigt__p_FIX__MDBookType,
  &_swigt__p_FIX__MDEntryBuyer,
  &_swigt__p_FIX__MDEntryDate,
  &_swigt__p_FIX__MDEntryForwardPoints,
  &_swigt__p_FIX__MDEntryID,
  &_swigt__p_FIX__MDEntryOriginator,
  &_swigt__p_FIX__MDEntryPositionNo,
  &_swigt__p_FIX__MDEntryPx,
  &_swigt__p_FIX__MDEntryRefID,
  &_swigt__p_FIX__MDEntrySeller,
  &_swigt__p_FIX__MDEntrySize,
  &_swigt__p_FIX__MDEntrySpotRate,
  &_swigt__p_FIX__MDEntryTime,
  &_swigt__p_FIX__MDEntryType,
  &_swigt__p_FIX__MDFeedType,
  &_swigt__p_FIX__MDImplicitDelete,
  &_swigt__p_FIX__MDMkt,
  &_swigt__p_FIX__MDOriginType,
  &_swigt__p_FIX__MDPriceLevel,
  &_swigt__p_FIX__MDQuoteType,
  &_swigt__p_FIX__MDReportID,
  &_swigt__p_FIX__MDReqID,
  &_swigt__p_FIX__MDReqRejReason,
  &_swigt__p_FIX__MDSecSize,
  &_swigt__p_FIX__MDSecSizeType,
  &_swigt__p_FIX__MDStreamID,
  &_swigt__p_FIX__MDSubBookType,
  &_swigt__p_FIX__MDUpdateAction,
  &_swigt__p_FIX__MDUpdateType,
  &_swigt__p_FIX__MONTHYEAR,
  &_swigt__p_FIX__MULTIPLECHARVALUE,
  &_swigt__p_FIX__MULTIPLESTRINGVALUE,
  &_swigt__p_FIX__MULTIPLEVALUESTRING,
  &_swigt__p_FIX__MailingDtls,
  &_swigt__p_FIX__MailingInst,
  &_swigt__p_FIX__ManualOrderIndicator,
  &_swigt__p_FIX__MarginExcess,
  &_swigt__p_FIX__MarginRatio,
  &_swigt__p_FIX__MarketDepth,
  &_swigt__p_FIX__MarketID,
  &_swigt__p_FIX__MarketReportID,
  &_swigt__p_FIX__MarketReqID,
  &_swigt__p_FIX__MarketSegmentDesc,
  &_swigt__p_FIX__MarketSegmentID,
  &_swigt__p_FIX__MarketUpdateAction,
  &_swigt__p_FIX__MassActionRejectReason,
  &_swigt__p_FIX__MassActionReportID,
  &_swigt__p_FIX__MassActionResponse,
  &_swigt__p_FIX__MassActionScope,
  &_swigt__p_FIX__MassActionType,
  &_swigt__p_FIX__MassCancelRejectReason,
  &_swigt__p_FIX__MassCancelRequestType,
  &_swigt__p_FIX__MassCancelResponse,
  &_swigt__p_FIX__MassStatusReqID,
  &_swigt__p_FIX__MassStatusReqType,
  &_swigt__p_FIX__MatchAlgorithm,
  &_swigt__p_FIX__MatchIncrement,
  &_swigt__p_FIX__MatchStatus,
  &_swigt__p_FIX__MatchType,
  &_swigt__p_FIX__MaturityDate,
  &_swigt__p_FIX__MaturityDay,
  &_swigt__p_FIX__MaturityMonthYear,
  &_swigt__p_FIX__MaturityMonthYearFormat,
  &_swigt__p_FIX__MaturityMonthYearIncrement,
  &_swigt__p_FIX__MaturityMonthYearIncrementUnits,
  &_swigt__p_FIX__MaturityNetMoney,
  &_swigt__p_FIX__MaturityRuleID,
  &_swigt__p_FIX__MaturityTime,
  &_swigt__p_FIX__MaxFloor,
  &_swigt__p_FIX__MaxMessageSize,
  &_swigt__p_FIX__MaxPriceLevels,
  &_swigt__p_FIX__MaxPriceVariation,
  &_swigt__p_FIX__MaxShow,
  &_swigt__p_FIX__MaxTradeVol,
  &_swigt__p_FIX__MemoryStore,
  &_swigt__p_FIX__MemoryStoreFactory,
  &_swigt__p_FIX__Message,
  &_swigt__p_FIX__MessageEncoding,
  &_swigt__p_FIX__MessageEventSource,
  &_swigt__p_FIX__MessageParseError,
  &_swigt__p_FIX__MessageStore,
  &_swigt__p_FIX__MessageStoreExceptionWrapper,
  &_swigt__p_FIX__MessageStoreFactory,
  &_swigt__p_FIX__MessageStoreFactoryExceptionWrapper,
  &_swigt__p_FIX__MidPx,
  &_swigt__p_FIX__MidYield,
  &_swigt__p_FIX__MinBidSize,
  &_swigt__p_FIX__MinLotSize,
  &_swigt__p_FIX__MinOfferSize,
  &_swigt__p_FIX__MinPriceIncrement,
  &_swigt__p_FIX__MinPriceIncrementAmount,
  &_swigt__p_FIX__MinQty,
  &_swigt__p_FIX__MinTradeVol,
  &_swigt__p_FIX__MiscFeeAmt,
  &_swigt__p_FIX__MiscFeeBasis,
  &_swigt__p_FIX__MiscFeeCurr,
  &_swigt__p_FIX__MiscFeeType,
  &_swigt__p_FIX__MktBidPx,
  &_swigt__p_FIX__MktOfferPx,
  &_swigt__p_FIX__ModelType,
  &_swigt__p_FIX__MoneyLaunderingStatus,
  &_swigt__p_FIX__MsgDirection,
  &_swigt__p_FIX__MsgSeqNum,
  &_swigt__p_FIX__MsgType,
  &_swigt__p_FIX__MultiLegReportingType,
  &_swigt__p_FIX__MultiLegRptTypeReq,
  &_swigt__p_FIX__MultilegModel,
  &_swigt__p_FIX__MultilegPriceMethod,
  &_swigt__p_FIX__NTPositionLimit,
  &_swigt__p_FIX__NUMINGROUP,
  &_swigt__p_FIX__Nested2PartyID,
  &_swigt__p_FIX__Nested2PartyIDSource,
  &_swigt__p_FIX__Nested2PartyRole,
  &_swigt__p_FIX__Nested2PartySubID,
  &_swigt__p_FIX__Nested2PartySubIDType,
  &_swigt__p_FIX__Nested3PartyID,
  &_swigt__p_FIX__Nested3PartyIDSource,
  &_swigt__p_FIX__Nested3PartyRole,
  &_swigt__p_FIX__Nested3PartySubID,
  &_swigt__p_FIX__Nested3PartySubIDType,
  &_swigt__p_FIX__Nested4PartyID,
  &_swigt__p_FIX__Nested4PartyIDSource,
  &_swigt__p_FIX__Nested4PartyRole,
  &_swigt__p_FIX__Nested4PartySubID,
  &_swigt__p_FIX__Nested4PartySubIDType,
  &_swigt__p_FIX__NestedInstrAttribType,
  &_swigt__p_FIX__NestedInstrAttribValue,
  &_swigt__p_FIX__NestedPartyID,
  &_swigt__p_FIX__NestedPartyIDSource,
  &_swigt__p_FIX__NestedPartyRole,
  &_swigt__p_FIX__NestedPartySubID,
  &_swigt__p_FIX__NestedPartySubIDType,
  &_swigt__p_FIX__NetChgPrevDay,
  &_swigt__p_FIX__NetGrossInd,
  &_swigt__p_FIX__NetMoney,
  &_swigt__p_FIX__NetworkRequestID,
  &_swigt__p_FIX__NetworkRequestType,
  &_swigt__p_FIX__NetworkResponseID,
  &_swigt__p_FIX__NetworkStatusResponseType,
  &_swigt__p_FIX__NewPassword,
  &_swigt__p_FIX__NewSeqNo,
  &_swigt__p_FIX__NewsCategory,
  &_swigt__p_FIX__NewsID,
  &_swigt__p_FIX__NewsRefID,
  &_swigt__p_FIX__NewsRefType,
  &_swigt__p_FIX__NextExpectedMsgSeqNum,
  &_swigt__p_FIX__NoAffectedOrders,
  &_swigt__p_FIX__NoAllocs,
  &_swigt__p_FIX__NoAltMDSource,
  &_swigt__p_FIX__NoApplIDs,
  &_swigt__p_FIX__NoAsgnReqs,
  &_swigt__p_FIX__NoBidComponents,
  &_swigt__p_FIX__NoBidDescriptors,
  &_swigt__p_FIX__NoCapacities,
  &_swigt__p_FIX__NoClearingInstructions,
  &_swigt__p_FIX__NoCollInquiryQualifier,
  &_swigt__p_FIX__NoCompIDs,
  &_swigt__p_FIX__NoComplexEventDates,
  &_swigt__p_FIX__NoComplexEventTimes,
  &_swigt__p_FIX__NoComplexEvents,
  &_swigt__p_FIX__NoContAmts,
  &_swigt__p_FIX__NoContextPartyIDs,
  &_swigt__p_FIX__NoContextPartySubIDs,
  &_swigt__p_FIX__NoContraBrokers,
  &_swigt__p_FIX__NoDates,
  &_swigt__p_FIX__NoDerivativeEvents,
  &_swigt__p_FIX__NoDerivativeInstrAttrib,
  &_swigt__p_FIX__NoDerivativeInstrumentParties,
  &_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs,
  &_swigt__p_FIX__NoDerivativeSecurityAltID,
  &_swigt__p_FIX__NoDistribInsts,
  &_swigt__p_FIX__NoDlvyInst,
  &_swigt__p_FIX__NoEvents,
  &_swigt__p_FIX__NoExecInstRules,
  &_swigt__p_FIX__NoExecs,
  &_swigt__p_FIX__NoExpiration,
  &_swigt__p_FIX__NoFills,
  &_swigt__p_FIX__NoHops,
  &_swigt__p_FIX__NoIOIQualifiers,
  &_swigt__p_FIX__NoInstrAttrib,
  &_swigt__p_FIX__NoInstrumentParties,
  &_swigt__p_FIX__NoInstrumentPartySubIDs,
  &_swigt__p_FIX__NoLegAllocs,
  &_swigt__p_FIX__NoLegSecurityAltID,
  &_swigt__p_FIX__NoLegStipulations,
  &_swigt__p_FIX__NoLegs,
  &_swigt__p_FIX__NoLinesOfText,
  &_swigt__p_FIX__NoLotTypeRules,
  &_swigt__p_FIX__NoMDEntries,
  &_swigt__p_FIX__NoMDEntryTypes,
  &_swigt__p_FIX__NoMDFeedTypes,
  &_swigt__p_FIX__NoMarketSegments,
  &_swigt__p_FIX__NoMatchRules,
  &_swigt__p_FIX__NoMaturityRules,
  &_swigt__p_FIX__NoMiscFees,
  &_swigt__p_FIX__NoMsgTypes,
  &_swigt__p_FIX__NoNested2PartyIDs,
  &_swigt__p_FIX__NoNested2PartySubIDs,
  &_swigt__p_FIX__NoNested3PartyIDs,
  &_swigt__p_FIX__NoNested3PartySubIDs,
  &_swigt__p_FIX__NoNested4PartyIDs,
  &_swigt__p_FIX__NoNested4PartySubIDs,
  &_swigt__p_FIX__NoNestedInstrAttrib,
  &_swigt__p_FIX__NoNestedPartyIDs,
  &_swigt__p_FIX__NoNestedPartySubIDs,
  &_swigt__p_FIX__NoNewsRefIDs,
  &_swigt__p_FIX__NoNotAffectedOrders,
  &_swigt__p_FIX__NoOfLegUnderlyings,
  &_swigt__p_FIX__NoOfSecSizes,
  &_swigt__p_FIX__NoOrdTypeRules,
  &_swigt__p_FIX__NoOrders,
  &_swigt__p_FIX__NoPartyAltIDs,
  &_swigt__p_FIX__NoPartyAltSubIDs,
  &_swigt__p_FIX__NoPartyIDs,
  &_swigt__p_FIX__NoPartyList,
  &_swigt__p_FIX__NoPartyListResponseTypes,
  &_swigt__p_FIX__NoPartyRelationships,
  &_swigt__p_FIX__NoPartySubIDs,
  &_swigt__p_FIX__NoPosAmt,
  &_swigt__p_FIX__NoPositions,
  &_swigt__p_FIX__NoQuoteEntries,
  &_swigt__p_FIX__NoQuoteQualifiers,
  &_swigt__p_FIX__NoQuoteSets,
  &_swigt__p_FIX__NoRateSources,
  &_swigt__p_FIX__NoRegistDtls,
  &_swigt__p_FIX__NoRelatedContextPartyIDs,
  &_swigt__p_FIX__NoRelatedContextPartySubIDs,
  &_swigt__p_FIX__NoRelatedPartyAltIDs,
  &_swigt__p_FIX__NoRelatedPartyAltSubIDs,
  &_swigt__p_FIX__NoRelatedPartyIDs,
  &_swigt__p_FIX__NoRelatedPartySubIDs,
  &_swigt__p_FIX__NoRelatedSym,
  &_swigt__p_FIX__NoRelationshipRiskInstruments,
  &_swigt__p_FIX__NoRelationshipRiskLimits,
  &_swigt__p_FIX__NoRelationshipRiskSecurityAltID,
  &_swigt__p_FIX__NoRelationshipRiskWarningLevels,
  &_swigt__p_FIX__NoRequestedPartyRoles,
  &_swigt__p_FIX__NoRiskInstruments,
  &_swigt__p_FIX__NoRiskLimits,
  &_swigt__p_FIX__NoRiskSecurityAltID,
  &_swigt__p_FIX__NoRiskWarningLevels,
  &_swigt__p_FIX__NoRootPartyIDs,
  &_swigt__p_FIX__NoRootPartySubIDs,
  &_swigt__p_FIX__NoRoutingIDs,
  &_swigt__p_FIX__NoRpts,
  &_swigt__p_FIX__NoSecurityAltID,
  &_swigt__p_FIX__NoSecurityTypes,
  &_swigt__p_FIX__NoSettlDetails,
  &_swigt__p_FIX__NoSettlInst,
  &_swigt__p_FIX__NoSettlOblig,
  &_swigt__p_FIX__NoSettlPartyIDs,
  &_swigt__p_FIX__NoSettlPartySubIDs,
  &_swigt__p_FIX__NoSideTrdRegTS,
  &_swigt__p_FIX__NoSides,
  &_swigt__p_FIX__NoStatsIndicators,
  &_swigt__p_FIX__NoStipulations,
  &_swigt__p_FIX__NoStrategyParameters,
  &_swigt__p_FIX__NoStrikeRules,
  &_swigt__p_FIX__NoStrikes,
  &_swigt__p_FIX__NoTagValue,
  &_swigt__p_FIX__NoTargetPartyIDs,
  &_swigt__p_FIX__NoTickRules,
  &_swigt__p_FIX__NoTimeInForceRules,
  &_swigt__p_FIX__NoTrades,
  &_swigt__p_FIX__NoTradingSessionRules,
  &_swigt__p_FIX__NoTradingSessions,
  &_swigt__p_FIX__NoTrdRegTimestamps,
  &_swigt__p_FIX__NoTrdRepIndicators,
  &_swigt__p_FIX__NoUnderlyingAmounts,
  &_swigt__p_FIX__NoUnderlyingLegSecurityAltID,
  &_swigt__p_FIX__NoUnderlyingSecurityAltID,
  &_swigt__p_FIX__NoUnderlyingStips,
  &_swigt__p_FIX__NoUnderlyings,
  &_swigt__p_FIX__NoUndlyInstrumentParties,
  &_swigt__p_FIX__NoUndlyInstrumentPartySubIDs,
  &_swigt__p_FIX__NotAffOrigClOrdID,
  &_swigt__p_FIX__NotAffectedOrderID,
  &_swigt__p_FIX__NotifyBrokerOfCredit,
  &_swigt__p_FIX__NotionalPercentageOutstanding,
  &_swigt__p_FIX__NullApplication,
  &_swigt__p_FIX__NullLog,
  &_swigt__p_FIX__NumBidders,
  &_swigt__p_FIX__NumDaysInterest,
  &_swigt__p_FIX__NumTickets,
  &_swigt__p_FIX__NumberOfOrders,
  &_swigt__p_FIX__OddLot,
  &_swigt__p_FIX__OfferForwardPoints,
  &_swigt__p_FIX__OfferForwardPoints2,
  &_swigt__p_FIX__OfferPx,
  &_swigt__p_FIX__OfferSize,
  &_swigt__p_FIX__OfferSpotRate,
  &_swigt__p_FIX__OfferSwapPoints,
  &_swigt__p_FIX__OfferYield,
  &_swigt__p_FIX__OnBehalfOfCompID,
  &_swigt__p_FIX__OnBehalfOfLocationID,
  &_swigt__p_FIX__OnBehalfOfSendingTime,
  &_swigt__p_FIX__OnBehalfOfSubID,
  &_swigt__p_FIX__OpenClose,
  &_swigt__p_FIX__OpenCloseSettlFlag,
  &_swigt__p_FIX__OpenCloseSettleFlag,
  &_swigt__p_FIX__OpenInterest,
  &_swigt__p_FIX__OptAttribute,
  &_swigt__p_FIX__OptPayAmount,
  &_swigt__p_FIX__OptPayoutAmount,
  &_swigt__p_FIX__OptPayoutType,
  &_swigt__p_FIX__OrdRejReason,
  &_swigt__p_FIX__OrdStatus,
  &_swigt__p_FIX__OrdStatusReqID,
  &_swigt__p_FIX__OrdType,
  &_swigt__p_FIX__OrderAvgPx,
  &_swigt__p_FIX__OrderBookingQty,
  &_swigt__p_FIX__OrderCapacity,
  &_swigt__p_FIX__OrderCapacityQty,
  &_swigt__p_FIX__OrderCategory,
  &_swigt__p_FIX__OrderDelay,
  &_swigt__p_FIX__OrderDelayUnit,
  &_swigt__p_FIX__OrderHandlingInstSource,
  &_swigt__p_FIX__OrderID,
  &_swigt__p_FIX__OrderInputDevice,
  &_swigt__p_FIX__OrderPercent,
  &_swigt__p_FIX__OrderQty,
  &_swigt__p_FIX__OrderQty2,
  &_swigt__p_FIX__OrderRestrictions,
  &_swigt__p_FIX__OrigClOrdID,
  &_swigt__p_FIX__OrigCrossID,
  &_swigt__p_FIX__OrigCustOrderCapacity,
  &_swigt__p_FIX__OrigOrdModTime,
  &_swigt__p_FIX__OrigPosReqRefID,
  &_swigt__p_FIX__OrigSecondaryTradeID,
  &_swigt__p_FIX__OrigSendingTime,
  &_swigt__p_FIX__OrigTime,
  &_swigt__p_FIX__OrigTradeDate,
  &_swigt__p_FIX__OrigTradeHandlingInstr,
  &_swigt__p_FIX__OrigTradeID,
  &_swigt__p_FIX__OriginalNotionalPercentageOutstanding,
  &_swigt__p_FIX__OutMainCntryUIndex,
  &_swigt__p_FIX__OutsideIndexPct,
  &_swigt__p_FIX__OwnerType,
  &_swigt__p_FIX__OwnershipType,
  &_swigt__p_FIX__PERCENTAGE,
  &_swigt__p_FIX__PRICE,
  &_swigt__p_FIX__PRICEOFFSET,
  &_swigt__p_FIX__ParentMktSegmID,
  &_swigt__p_FIX__ParticipationRate,
  &_swigt__p_FIX__PartyAltID,
  &_swigt__p_FIX__PartyAltIDSource,
  &_swigt__p_FIX__PartyAltSubID,
  &_swigt__p_FIX__PartyAltSubIDType,
  &_swigt__p_FIX__PartyDetailsListReportID,
  &_swigt__p_FIX__PartyDetailsListRequestID,
  &_swigt__p_FIX__PartyDetailsRequestResult,
  &_swigt__p_FIX__PartyID,
  &_swigt__p_FIX__PartyIDSource,
  &_swigt__p_FIX__PartyListResponseType,
  &_swigt__p_FIX__PartyRelationship,
  &_swigt__p_FIX__PartyRole,
  &_swigt__p_FIX__PartySubID,
  &_swigt__p_FIX__PartySubIDType,
  &_swigt__p_FIX__Password,
  &_swigt__p_FIX__PaymentDate,
  &_swigt__p_FIX__PaymentMethod,
  &_swigt__p_FIX__PaymentRef,
  &_swigt__p_FIX__PaymentRemitterID,
  &_swigt__p_FIX__PctAtRisk,
  &_swigt__p_FIX__PegDifference,
  &_swigt__p_FIX__PegLimitType,
  &_swigt__p_FIX__PegMoveType,
  &_swigt__p_FIX__PegOffsetType,
  &_swigt__p_FIX__PegOffsetValue,
  &_swigt__p_FIX__PegPriceType,
  &_swigt__p_FIX__PegRoundDirection,
  &_swigt__p_FIX__PegScope,
  &_swigt__p_FIX__PegSecurityDesc,
  &_swigt__p_FIX__PegSecurityID,
  &_swigt__p_FIX__PegSecurityIDSource,
  &_swigt__p_FIX__PegSymbol,
  &_swigt__p_FIX__PeggedPrice,
  &_swigt__p_FIX__PeggedRefPrice,
  &_swigt__p_FIX__Pool,
  &_swigt__p_FIX__PosAmt,
  &_swigt__p_FIX__PosAmtType,
  &_swigt__p_FIX__PosMaintAction,
  &_swigt__p_FIX__PosMaintResult,
  &_swigt__p_FIX__PosMaintRptID,
  &_swigt__p_FIX__PosMaintRptRefID,
  &_swigt__p_FIX__PosMaintStatus,
  &_swigt__p_FIX__PosQtyStatus,
  &_swigt__p_FIX__PosReqID,
  &_swigt__p_FIX__PosReqResult,
  &_swigt__p_FIX__PosReqStatus,
  &_swigt__p_FIX__PosReqType,
  &_swigt__p_FIX__PosTransType,
  &_swigt__p_FIX__PosType,
  &_swigt__p_FIX__PositionCurrency,
  &_swigt__p_FIX__PositionEffect,
  &_swigt__p_FIX__PositionLimit,
  &_swigt__p_FIX__PossDupFlag,
  &_swigt__p_FIX__PossResend,
  &_swigt__p_FIX__PreTradeAnonymity,
  &_swigt__p_FIX__PreallocMethod,
  &_swigt__p_FIX__PrevClosePx,
  &_swigt__p_FIX__PreviouslyReported,
  &_swigt__p_FIX__Price,
  &_swigt__p_FIX__Price2,
  &_swigt__p_FIX__PriceDelta,
  &_swigt__p_FIX__PriceImprovement,
  &_swigt__p_FIX__PriceLimitType,
  &_swigt__p_FIX__PriceProtectionScope,
  &_swigt__p_FIX__PriceQuoteMethod,
  &_swigt__p_FIX__PriceType,
  &_swigt__p_FIX__PriceUnitOfMeasure,
  &_swigt__p_FIX__PriceUnitOfMeasureQty,
  &_swigt__p_FIX__PriorSettlPrice,
  &_swigt__p_FIX__PriorSpreadIndicator,
  &_swigt__p_FIX__PriorityIndicator,
  &_swigt__p_FIX__PrivateQuote,
  &_swigt__p_FIX__ProcessCode,
  &_swigt__p_FIX__Product,
  &_swigt__p_FIX__ProductComplex,
  &_swigt__p_FIX__ProgPeriodInterval,
  &_swigt__p_FIX__ProgRptReqs,
  &_swigt__p_FIX__PublishTrdIndicator,
  &_swigt__p_FIX__PutOrCall,
  &_swigt__p_FIX__QTY,
  &_swigt__p_FIX__QtyType,
  &_swigt__p_FIX__Quantity,
  &_swigt__p_FIX__QuantityDate,
  &_swigt__p_FIX__QuantityType,
  &_swigt__p_FIX__QuoteAckStatus,
  &_swigt__p_FIX__QuoteCancelType,
  &_swigt__p_FIX__QuoteCondition,
  &_swigt__p_FIX__QuoteEntryID,
  &_swigt__p_FIX__QuoteEntryRejectReason,
  &_swigt__p_FIX__QuoteEntryStatus,
  &_swigt__p_FIX__QuoteID,
  &_swigt__p_FIX__QuoteMsgID,
  &_swigt__p_FIX__QuotePriceType,
  &_swigt__p_FIX__QuoteQualifier,
  &_swigt__p_FIX__QuoteRejectReason,
  &_swigt__p_FIX__QuoteReqID,
  &_swigt__p_FIX__QuoteRequestRejectReason,
  &_swigt__p_FIX__QuoteRequestType,
  &_swigt__p_FIX__QuoteRespID,
  &_swigt__p_FIX__QuoteRespType,
  &_swigt__p_FIX__QuoteResponseLevel,
  &_swigt__p_FIX__QuoteSetID,
  &_swigt__p_FIX__QuoteSetValidUntilTime,
  &_swigt__p_FIX__QuoteStatus,
  &_swigt__p_FIX__QuoteStatusReqID,
  &_swigt__p_FIX__QuoteType,
  &_swigt__p_FIX__RFQReqID,
  &_swigt__p_FIX__RateSource,
  &_swigt__p_FIX__RateSourceType,
  &_swigt__p_FIX__RatioQty,
  &_swigt__p_FIX__RawData,
  &_swigt__p_FIX__RawDataLength,
  &_swigt__p_FIX__ReceivedDeptID,
  &_swigt__p_FIX__RedemptionDate,
  &_swigt__p_FIX__RefAllocID,
  &_swigt__p_FIX__RefApplExtID,
  &_swigt__p_FIX__RefApplID,
  &_swigt__p_FIX__RefApplLastSeqNum,
  &_swigt__p_FIX__RefApplReqID,
  &_swigt__p_FIX__RefApplVerID,
  &_swigt__p_FIX__RefCompID,
  &_swigt__p_FIX__RefCstmApplVerID,
  &_swigt__p_FIX__RefMsgType,
  &_swigt__p_FIX__RefOrdIDReason,
  &_swigt__p_FIX__RefOrderID,
  &_swigt__p_FIX__RefOrderIDSource,
  &_swigt__p_FIX__RefSeqNum,
  &_swigt__p_FIX__RefSubID,
  &_swigt__p_FIX__RefTagID,
  &_swigt__p_FIX__ReferencePage,
  &_swigt__p_FIX__RefreshIndicator,
  &_swigt__p_FIX__RefreshQty,
  &_swigt__p_FIX__RegistAcctType,
  &_swigt__p_FIX__RegistDetls,
  &_swigt__p_FIX__RegistDtls,
  &_swigt__p_FIX__RegistEmail,
  &_swigt__p_FIX__RegistID,
  &_swigt__p_FIX__RegistRefID,
  &_swigt__p_FIX__RegistRejReasonCode,
  &_swigt__p_FIX__RegistRejReasonText,
  &_swigt__p_FIX__RegistStatus,
  &_swigt__p_FIX__RegistTransType,
  &_swigt__p_FIX__RejectLogon,
  &_swigt__p_FIX__RejectText,
  &_swigt__p_FIX__RelSymTransactTime,
  &_swigt__p_FIX__RelatdSym,
  &_swigt__p_FIX__RelatedContextPartyID,
  &_swigt__p_FIX__RelatedContextPartyIDSource,
  &_swigt__p_FIX__RelatedContextPartyRole,
  &_swigt__p_FIX__RelatedContextPartySubID,
  &_swigt__p_FIX__RelatedContextPartySubIDType,
  &_swigt__p_FIX__RelatedPartyAltID,
  &_swigt__p_FIX__RelatedPartyAltIDSource,
  &_swigt__p_FIX__RelatedPartyAltSubID,
  &_swigt__p_FIX__RelatedPartyAltSubIDType,
  &_swigt__p_FIX__RelatedPartyID,
  &_swigt__p_FIX__RelatedPartyIDSource,
  &_swigt__p_FIX__RelatedPartyRole,
  &_swigt__p_FIX__RelatedPartySubID,
  &_swigt__p_FIX__RelatedPartySubIDType,
  &_swigt__p_FIX__RelationshipRiskCFICode,
  &_swigt__p_FIX__RelationshipRiskCouponRate,
  &_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc,
  &_swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen,
  &_swigt__p_FIX__RelationshipRiskFlexibleIndicator,
  &_swigt__p_FIX__RelationshipRiskInstrumentMultiplier,
  &_swigt__p_FIX__RelationshipRiskInstrumentOperator,
  &_swigt__p_FIX__RelationshipRiskInstrumentSettlType,
  &_swigt__p_FIX__RelationshipRiskLimitAmount,
  &_swigt__p_FIX__RelationshipRiskLimitCurrency,
  &_swigt__p_FIX__RelationshipRiskLimitPlatform,
  &_swigt__p_FIX__RelationshipRiskLimitType,
  &_swigt__p_FIX__RelationshipRiskMaturityMonthYear,
  &_swigt__p_FIX__RelationshipRiskMaturityTime,
  &_swigt__p_FIX__RelationshipRiskProduct,
  &_swigt__p_FIX__RelationshipRiskProductComplex,
  &_swigt__p_FIX__RelationshipRiskPutOrCall,
  &_swigt__p_FIX__RelationshipRiskRestructuringType,
  &_swigt__p_FIX__RelationshipRiskSecurityAltID,
  &_swigt__p_FIX__RelationshipRiskSecurityAltIDSource,
  &_swigt__p_FIX__RelationshipRiskSecurityDesc,
  &_swigt__p_FIX__RelationshipRiskSecurityExchange,
  &_swigt__p_FIX__RelationshipRiskSecurityGroup,
  &_swigt__p_FIX__RelationshipRiskSecurityID,
  &_swigt__p_FIX__RelationshipRiskSecurityIDSource,
  &_swigt__p_FIX__RelationshipRiskSecuritySubType,
  &_swigt__p_FIX__RelationshipRiskSecurityType,
  &_swigt__p_FIX__RelationshipRiskSeniority,
  &_swigt__p_FIX__RelationshipRiskSymbol,
  &_swigt__p_FIX__RelationshipRiskSymbolSfx,
  &_swigt__p_FIX__RelationshipRiskWarningLevelName,
  &_swigt__p_FIX__RelationshipRiskWarningLevelPercent,
  &_swigt__p_FIX__RepeatedTag,
  &_swigt__p_FIX__RepeatingGroupCountMismatch,
  &_swigt__p_FIX__RepoCollateralSecurityType,
  &_swigt__p_FIX__ReportToExch,
  &_swigt__p_FIX__ReportedPx,
  &_swigt__p_FIX__ReportedPxDiff,
  &_swigt__p_FIX__RepurchaseRate,
  &_swigt__p_FIX__RepurchaseTerm,
  &_swigt__p_FIX__RequestedPartyRole,
  &_swigt__p_FIX__RequiredTagMissing,
  &_swigt__p_FIX__ResetSeqNumFlag,
  &_swigt__p_FIX__RespondentType,
  &_swigt__p_FIX__ResponseDestination,
  &_swigt__p_FIX__ResponseTransportType,
  &_swigt__p_FIX__RestructuringType,
  &_swigt__p_FIX__ReversalIndicator,
  &_swigt__p_FIX__RiskCFICode,
  &_swigt__p_FIX__RiskCouponRate,
  &_swigt__p_FIX__RiskEncodedSecurityDesc,
  &_swigt__p_FIX__RiskEncodedSecurityDescLen,
  &_swigt__p_FIX__RiskFlexibleIndicator,
  &_swigt__p_FIX__RiskFreeRate,
  &_swigt__p_FIX__RiskInstrumentMultiplier,
  &_swigt__p_FIX__RiskInstrumentOperator,
  &_swigt__p_FIX__RiskInstrumentSettlType,
  &_swigt__p_FIX__RiskLimitAmount,
  &_swigt__p_FIX__RiskLimitCurrency,
  &_swigt__p_FIX__RiskLimitPlatform,
  &_swigt__p_FIX__RiskLimitType,
  &_swigt__p_FIX__RiskMaturityMonthYear,
  &_swigt__p_FIX__RiskMaturityTime,
  &_swigt__p_FIX__RiskProduct,
  &_swigt__p_FIX__RiskProductComplex,
  &_swigt__p_FIX__RiskPutOrCall,
  &_swigt__p_FIX__RiskRestructuringType,
  &_swigt__p_FIX__RiskSecurityAltID,
  &_swigt__p_FIX__RiskSecurityAltIDSource,
  &_swigt__p_FIX__RiskSecurityDesc,
  &_swigt__p_FIX__RiskSecurityExchange,
  &_swigt__p_FIX__RiskSecurityGroup,
  &_swigt__p_FIX__RiskSecurityID,
  &_swigt__p_FIX__RiskSecurityIDSource,
  &_swigt__p_FIX__RiskSecuritySubType,
  &_swigt__p_FIX__RiskSecurityType,
  &_swigt__p_FIX__RiskSeniority,
  &_swigt__p_FIX__RiskSymbol,
  &_swigt__p_FIX__RiskSymbolSfx,
  &_swigt__p_FIX__RiskWarningLevelName,
  &_swigt__p_FIX__RiskWarningLevelPercent,
  &_swigt__p_FIX__RndPx,
  &_swigt__p_FIX__RootPartyID,
  &_swigt__p_FIX__RootPartyIDSource,
  &_swigt__p_FIX__RootPartyRole,
  &_swigt__p_FIX__RootPartySubID,
  &_swigt__p_FIX__RootPartySubIDType,
  &_swigt__p_FIX__RoundLot,
  &_swigt__p_FIX__RoundingDirection,
  &_swigt__p_FIX__RoundingModulus,
  &_swigt__p_FIX__RoutingID,
  &_swigt__p_FIX__RoutingType,
  &_swigt__p_FIX__RptSeq,
  &_swigt__p_FIX__RptSys,
  &_swigt__p_FIX__Rule80A,
  &_swigt__p_FIX__RuntimeError,
  &_swigt__p_FIX__SEQNUM,
  &_swigt__p_FIX__STRING,
  &_swigt__p_FIX__Scope,
  &_swigt__p_FIX__ScreenLog,
  &_swigt__p_FIX__ScreenLogFactory,
  &_swigt__p_FIX__SecDefStatus,
  &_swigt__p_FIX__SecondaryAllocID,
  &_swigt__p_FIX__SecondaryClOrdID,
  &_swigt__p_FIX__SecondaryDisplayQty,
  &_swigt__p_FIX__SecondaryExecID,
  &_swigt__p_FIX__SecondaryFirmTradeID,
  &_swigt__p_FIX__SecondaryHighLimitPrice,
  &_swigt__p_FIX__SecondaryIndividualAllocID,
  &_swigt__p_FIX__SecondaryLowLimitPrice,
  &_swigt__p_FIX__SecondaryOrderID,
  &_swigt__p_FIX__SecondaryPriceLimitType,
  &_swigt__p_FIX__SecondaryTradeID,
  &_swigt__p_FIX__SecondaryTradeReportID,
  &_swigt__p_FIX__SecondaryTradeReportRefID,
  &_swigt__p_FIX__SecondaryTradingReferencePrice,
  &_swigt__p_FIX__SecondaryTrdType,
  &_swigt__p_FIX__SecureData,
  &_swigt__p_FIX__SecureDataLen,
  &_swigt__p_FIX__SecurityAltID,
  &_swigt__p_FIX__SecurityAltIDSource,
  &_swigt__p_FIX__SecurityDesc,
  &_swigt__p_FIX__SecurityExchange,
  &_swigt__p_FIX__SecurityGroup,
  &_swigt__p_FIX__SecurityID,
  &_swigt__p_FIX__SecurityIDSource,
  &_swigt__p_FIX__SecurityListDesc,
  &_swigt__p_FIX__SecurityListID,
  &_swigt__p_FIX__SecurityListRefID,
  &_swigt__p_FIX__SecurityListRequestType,
  &_swigt__p_FIX__SecurityListType,
  &_swigt__p_FIX__SecurityListTypeSource,
  &_swigt__p_FIX__SecurityReportID,
  &_swigt__p_FIX__SecurityReqID,
  &_swigt__p_FIX__SecurityRequestResult,
  &_swigt__p_FIX__SecurityRequestType,
  &_swigt__p_FIX__SecurityResponseID,
  &_swigt__p_FIX__SecurityResponseType,
  &_swigt__p_FIX__SecuritySettlAgentAcctName,
  &_swigt__p_FIX__SecuritySettlAgentAcctNum,
  &_swigt__p_FIX__SecuritySettlAgentCode,
  &_swigt__p_FIX__SecuritySettlAgentContactName,
  &_swigt__p_FIX__SecuritySettlAgentContactPhone,
  &_swigt__p_FIX__SecuritySettlAgentName,
  &_swigt__p_FIX__SecurityStatus,
  &_swigt__p_FIX__SecurityStatusReqID,
  &_swigt__p_FIX__SecuritySubType,
  &_swigt__p_FIX__SecurityTradingEvent,
  &_swigt__p_FIX__SecurityTradingStatus,
  &_swigt__p_FIX__SecurityType,
  &_swigt__p_FIX__SecurityUpdateAction,
  &_swigt__p_FIX__SecurityXML,
  &_swigt__p_FIX__SecurityXMLLen,
  &_swigt__p_FIX__SecurityXMLSchema,
  &_swigt__p_FIX__SellVolume,
  &_swigt__p_FIX__SellerDays,
  &_swigt__p_FIX__SenderCompID,
  &_swigt__p_FIX__SenderLocationID,
  &_swigt__p_FIX__SenderSubID,
  &_swigt__p_FIX__SendingDate,
  &_swigt__p_FIX__SendingTime,
  &_swigt__p_FIX__Seniority,
  &_swigt__p_FIX__Session,
  &_swigt__p_FIX__SessionID,
  &_swigt__p_FIX__SessionNotFound,
  &_swigt__p_FIX__SessionRejectReason,
  &_swigt__p_FIX__SessionSettings,
  &_swigt__p_FIX__SessionStatus,
  &_swigt__p_FIX__SettlBrkrCode,
  &_swigt__p_FIX__SettlCurrAmt,
  &_swigt__p_FIX__SettlCurrBidFxRate,
  &_swigt__p_FIX__SettlCurrFxRate,
  &_swigt__p_FIX__SettlCurrFxRateCalc,
  &_swigt__p_FIX__SettlCurrOfferFxRate,
  &_swigt__p_FIX__SettlCurrency,
  &_swigt__p_FIX__SettlDate,
  &_swigt__p_FIX__SettlDate2,
  &_swigt__p_FIX__SettlDeliveryType,
  &_swigt__p_FIX__SettlDepositoryCode,
  &_swigt__p_FIX__SettlInstCode,
  &_swigt__p_FIX__SettlInstID,
  &_swigt__p_FIX__SettlInstMode,
  &_swigt__p_FIX__SettlInstMsgID,
  &_swigt__p_FIX__SettlInstRefID,
  &_swigt__p_FIX__SettlInstReqID,
  &_swigt__p_FIX__SettlInstReqRejCode,
  &_swigt__p_FIX__SettlInstSource,
  &_swigt__p_FIX__SettlInstTransType,
  &_swigt__p_FIX__SettlLocation,
  &_swigt__p_FIX__SettlMethod,
  &_swigt__p_FIX__SettlObligID,
  &_swigt__p_FIX__SettlObligMode,
  &_swigt__p_FIX__SettlObligMsgID,
  &_swigt__p_FIX__SettlObligRefID,
  &_swigt__p_FIX__SettlObligSource,
  &_swigt__p_FIX__SettlObligTransType,
  &_swigt__p_FIX__SettlPartyID,
  &_swigt__p_FIX__SettlPartyIDSource,
  &_swigt__p_FIX__SettlPartyRole,
  &_swigt__p_FIX__SettlPartySubID,
  &_swigt__p_FIX__SettlPartySubIDType,
  &_swigt__p_FIX__SettlPrice,
  &_swigt__p_FIX__SettlPriceType,
  &_swigt__p_FIX__SettlSessID,
  &_swigt__p_FIX__SettlSessSubID,
  &_swigt__p_FIX__SettlType,
  &_swigt__p_FIX__SettleOnOpenFlag,
  &_swigt__p_FIX__SettlementCycleNo,
  &_swigt__p_FIX__SettlmntTyp,
  &_swigt__p_FIX__SharedCommission,
  &_swigt__p_FIX__Shares,
  &_swigt__p_FIX__ShortQty,
  &_swigt__p_FIX__ShortSaleReason,
  &_swigt__p_FIX__Side,
  &_swigt__p_FIX__SideComplianceID,
  &_swigt__p_FIX__SideCurrency,
  &_swigt__p_FIX__SideExecID,
  &_swigt__p_FIX__SideFillStationCd,
  &_swigt__p_FIX__SideGrossTradeAmt,
  &_swigt__p_FIX__SideLastQty,
  &_swigt__p_FIX__SideLiquidityInd,
  &_swigt__p_FIX__SideMultiLegReportingType,
  &_swigt__p_FIX__SideQty,
  &_swigt__p_FIX__SideReasonCd,
  &_swigt__p_FIX__SideSettlCurrency,
  &_swigt__p_FIX__SideTimeInForce,
  &_swigt__p_FIX__SideTradeReportID,
  &_swigt__p_FIX__SideTrdRegTimestamp,
  &_swigt__p_FIX__SideTrdRegTimestampSrc,
  &_swigt__p_FIX__SideTrdRegTimestampType,
  &_swigt__p_FIX__SideTrdSubTyp,
  &_swigt__p_FIX__SideValue1,
  &_swigt__p_FIX__SideValue2,
  &_swigt__p_FIX__SideValueInd,
  &_swigt__p_FIX__Signature,
  &_swigt__p_FIX__SignatureLength,
  &_swigt__p_FIX__SocketAcceptor,
  &_swigt__p_FIX__SocketCloseFailed,
  &_swigt__p_FIX__SocketException,
  &_swigt__p_FIX__SocketInitiator,
  &_swigt__p_FIX__SocketRecvFailed,
  &_swigt__p_FIX__SocketSendFailed,
  &_swigt__p_FIX__SolicitedFlag,
  &_swigt__p_FIX__Spread,
  &_swigt__p_FIX__SpreadToBenchmark,
  &_swigt__p_FIX__StandInstDbID,
  &_swigt__p_FIX__StandInstDbName,
  &_swigt__p_FIX__StandInstDbType,
  &_swigt__p_FIX__StartCash,
  &_swigt__p_FIX__StartDate,
  &_swigt__p_FIX__StartMaturityMonthYear,
  &_swigt__p_FIX__StartStrikePxRange,
  &_swigt__p_FIX__StartTickPriceRange,
  &_swigt__p_FIX__StateOrProvinceOfIssue,
  &_swigt__p_FIX__StatsType,
  &_swigt__p_FIX__StatusText,
  &_swigt__p_FIX__StatusValue,
  &_swigt__p_FIX__StipulationType,
  &_swigt__p_FIX__StipulationValue,
  &_swigt__p_FIX__StopPx,
  &_swigt__p_FIX__StrategyParameterName,
  &_swigt__p_FIX__StrategyParameterType,
  &_swigt__p_FIX__StrategyParameterValue,
  &_swigt__p_FIX__StreamAsgnAckType,
  &_swigt__p_FIX__StreamAsgnRejReason,
  &_swigt__p_FIX__StreamAsgnReqID,
  &_swigt__p_FIX__StreamAsgnReqType,
  &_swigt__p_FIX__StreamAsgnRptID,
  &_swigt__p_FIX__StreamAsgnType,
  &_swigt__p_FIX__StrikeCurrency,
  &_swigt__p_FIX__StrikeExerciseStyle,
  &_swigt__p_FIX__StrikeIncrement,
  &_swigt__p_FIX__StrikeMultiplier,
  &_swigt__p_FIX__StrikePrice,
  &_swigt__p_FIX__StrikePriceBoundaryMethod,
  &_swigt__p_FIX__StrikePriceBoundaryPrecision,
  &_swigt__p_FIX__StrikePriceDeterminationMethod,
  &_swigt__p_FIX__StrikeRuleID,
  &_swigt__p_FIX__StrikeTime,
  &_swigt__p_FIX__StrikeValue,
  &_swigt__p_FIX__StringField,
  &_swigt__p_FIX__Subject,
  &_swigt__p_FIX__SubscriptionRequestType,
  &_swigt__p_FIX__SwapPoints,
  &_swigt__p_FIX__Symbol,
  &_swigt__p_FIX__SymbolSfx,
  &_swigt__p_FIX__SynchronizedApplication,
  &_swigt__p_FIX__TYPE__Type,
  &_swigt__p_FIX__TZTIMEONLY,
  &_swigt__p_FIX__TZTIMESTAMP,
  &_swigt__p_FIX__TZTransactTime,
  &_swigt__p_FIX__TagNotDefinedForMessage,
  &_swigt__p_FIX__TagOutOfOrder,
  &_swigt__p_FIX__TargetCompID,
  &_swigt__p_FIX__TargetLocationID,
  &_swigt__p_FIX__TargetPartyID,
  &_swigt__p_FIX__TargetPartyIDSource,
  &_swigt__p_FIX__TargetPartyRole,
  &_swigt__p_FIX__TargetStrategy,
  &_swigt__p_FIX__TargetStrategyParameters,
  &_swigt__p_FIX__TargetStrategyPerformance,
  &_swigt__p_FIX__TargetSubID,
  &_swigt__p_FIX__TaxAdvantageType,
  &_swigt__p_FIX__TerminationType,
  &_swigt__p_FIX__TestMessageIndicator,
  &_swigt__p_FIX__TestReqID,
  &_swigt__p_FIX__Text,
  &_swigt__p_FIX__ThresholdAmount,
  &_swigt__p_FIX__TickDirection,
  &_swigt__p_FIX__TickIncrement,
  &_swigt__p_FIX__TickRuleType,
  &_swigt__p_FIX__TierCode,
  &_swigt__p_FIX__TimeBracket,
  &_swigt__p_FIX__TimeInForce,
  &_swigt__p_FIX__TimeToExpiration,
  &_swigt__p_FIX__TimeUnit,
  &_swigt__p_FIX__TotNoAccQuotes,
  &_swigt__p_FIX__TotNoAllocs,
  &_swigt__p_FIX__TotNoCxldQuotes,
  &_swigt__p_FIX__TotNoFills,
  &_swigt__p_FIX__TotNoOrders,
  &_swigt__p_FIX__TotNoPartyList,
  &_swigt__p_FIX__TotNoQuoteEntries,
  &_swigt__p_FIX__TotNoRejQuotes,
  &_swigt__p_FIX__TotNoRelatedSym,
  &_swigt__p_FIX__TotNoSecurityTypes,
  &_swigt__p_FIX__TotNoStrikes,
  &_swigt__p_FIX__TotNumAssignmentReports,
  &_swigt__p_FIX__TotNumReports,
  &_swigt__p_FIX__TotNumTradeReports,
  &_swigt__p_FIX__TotQuoteEntries,
  &_swigt__p_FIX__TotalAccruedInterestAmt,
  &_swigt__p_FIX__TotalAffectedOrders,
  &_swigt__p_FIX__TotalNetValue,
  &_swigt__p_FIX__TotalNumPosReports,
  &_swigt__p_FIX__TotalNumSecurities,
  &_swigt__p_FIX__TotalNumSecurityTypes,
  &_swigt__p_FIX__TotalTakedown,
  &_swigt__p_FIX__TotalVolumeTraded,
  &_swigt__p_FIX__TotalVolumeTradedDate,
  &_swigt__p_FIX__TotalVolumeTradedTime,
  &_swigt__p_FIX__TradSesCloseTime,
  &_swigt__p_FIX__TradSesEndTime,
  &_swigt__p_FIX__TradSesEvent,
  &_swigt__p_FIX__TradSesMethod,
  &_swigt__p_FIX__TradSesMode,
  &_swigt__p_FIX__TradSesOpenTime,
  &_swigt__p_FIX__TradSesPreCloseTime,
  &_swigt__p_FIX__TradSesReqID,
  &_swigt__p_FIX__TradSesStartTime,
  &_swigt__p_FIX__TradSesStatus,
  &_swigt__p_FIX__TradSesStatusRejReason,
  &_swigt__p_FIX__TradSesUpdateAction,
  &_swigt__p_FIX__TradeAllocIndicator,
  &_swigt__p_FIX__TradeCondition,
  &_swigt__p_FIX__TradeDate,
  &_swigt__p_FIX__TradeHandlingInstr,
  &_swigt__p_FIX__TradeID,
  &_swigt__p_FIX__TradeInputDevice,
  &_swigt__p_FIX__TradeInputSource,
  &_swigt__p_FIX__TradeLegRefID,
  &_swigt__p_FIX__TradeLinkID,
  &_swigt__p_FIX__TradeOriginationDate,
  &_swigt__p_FIX__TradePublishIndicator,
  &_swigt__p_FIX__TradeReportID,
  &_swigt__p_FIX__TradeReportRefID,
  &_swigt__p_FIX__TradeReportRejectReason,
  &_swigt__p_FIX__TradeReportTransType,
  &_swigt__p_FIX__TradeReportType,
  &_swigt__p_FIX__TradeRequestID,
  &_swigt__p_FIX__TradeRequestResult,
  &_swigt__p_FIX__TradeRequestStatus,
  &_swigt__p_FIX__TradeRequestType,
  &_swigt__p_FIX__TradeType,
  &_swigt__p_FIX__TradeVolume,
  &_swigt__p_FIX__TradedFlatSwitch,
  &_swigt__p_FIX__TradingCurrency,
  &_swigt__p_FIX__TradingReferencePrice,
  &_swigt__p_FIX__TradingSessionDesc,
  &_swigt__p_FIX__TradingSessionID,
  &_swigt__p_FIX__TradingSessionSubID,
  &_swigt__p_FIX__TransBkdTime,
  &_swigt__p_FIX__TransactTime,
  &_swigt__p_FIX__TransferReason,
  &_swigt__p_FIX__TrdMatchID,
  &_swigt__p_FIX__TrdRegTimestamp,
  &_swigt__p_FIX__TrdRegTimestampOrigin,
  &_swigt__p_FIX__TrdRegTimestampType,
  &_swigt__p_FIX__TrdRepIndicator,
  &_swigt__p_FIX__TrdRepPartyRole,
  &_swigt__p_FIX__TrdRptStatus,
  &_swigt__p_FIX__TrdSubType,
  &_swigt__p_FIX__TrdType,
  &_swigt__p_FIX__TriggerAction,
  &_swigt__p_FIX__TriggerNewPrice,
  &_swigt__p_FIX__TriggerNewQty,
  &_swigt__p_FIX__TriggerOrderType,
  &_swigt__p_FIX__TriggerPrice,
  &_swigt__p_FIX__TriggerPriceDirection,
  &_swigt__p_FIX__TriggerPriceType,
  &_swigt__p_FIX__TriggerPriceTypeScope,
  &_swigt__p_FIX__TriggerSecurityDesc,
  &_swigt__p_FIX__TriggerSecurityID,
  &_swigt__p_FIX__TriggerSecurityIDSource,
  &_swigt__p_FIX__TriggerSymbol,
  &_swigt__p_FIX__TriggerTradingSessionID,
  &_swigt__p_FIX__TriggerTradingSessionSubID,
  &_swigt__p_FIX__TriggerType,
  &_swigt__p_FIX__URLLink,
  &_swigt__p_FIX__UTCDATEONLY,
  &_swigt__p_FIX__UTCTIMEONLY,
  &_swigt__p_FIX__UTCTIMESTAMP,
  &_swigt__p_FIX__UnderlyingAdjustedQuantity,
  &_swigt__p_FIX__UnderlyingAllocationPercent,
  &_swigt__p_FIX__UnderlyingAttachmentPoint,
  &_swigt__p_FIX__UnderlyingCFICode,
  &_swigt__p_FIX__UnderlyingCPProgram,
  &_swigt__p_FIX__UnderlyingCPRegType,
  &_swigt__p_FIX__UnderlyingCapValue,
  &_swigt__p_FIX__UnderlyingCashAmount,
  &_swigt__p_FIX__UnderlyingCashType,
  &_swigt__p_FIX__UnderlyingCollectAmount,
  &_swigt__p_FIX__UnderlyingContractMultiplier,
  &_swigt__p_FIX__UnderlyingContractMultiplierUnit,
  &_swigt__p_FIX__UnderlyingCountryOfIssue,
  &_swigt__p_FIX__UnderlyingCouponPaymentDate,
  &_swigt__p_FIX__UnderlyingCouponRate,
  &_swigt__p_FIX__UnderlyingCreditRating,
  &_swigt__p_FIX__UnderlyingCurrency,
  &_swigt__p_FIX__UnderlyingCurrentValue,
  &_swigt__p_FIX__UnderlyingDeliveryAmount,
  &_swigt__p_FIX__UnderlyingDetachmentPoint,
  &_swigt__p_FIX__UnderlyingDirtyPrice,
  &_swigt__p_FIX__UnderlyingEndPrice,
  &_swigt__p_FIX__UnderlyingEndValue,
  &_swigt__p_FIX__UnderlyingExerciseStyle,
  &_swigt__p_FIX__UnderlyingFXRate,
  &_swigt__p_FIX__UnderlyingFXRateCalc,
  &_swigt__p_FIX__UnderlyingFactor,
  &_swigt__p_FIX__UnderlyingFlowScheduleType,
  &_swigt__p_FIX__UnderlyingIDSource,
  &_swigt__p_FIX__UnderlyingInstrRegistry,
  &_swigt__p_FIX__UnderlyingInstrumentPartyID,
  &_swigt__p_FIX__UnderlyingInstrumentPartyIDSource,
  &_swigt__p_FIX__UnderlyingInstrumentPartyRole,
  &_swigt__p_FIX__UnderlyingInstrumentPartySubID,
  &_swigt__p_FIX__UnderlyingInstrumentPartySubIDType,
  &_swigt__p_FIX__UnderlyingIssueDate,
  &_swigt__p_FIX__UnderlyingIssuer,
  &_swigt__p_FIX__UnderlyingLastPx,
  &_swigt__p_FIX__UnderlyingLastQty,
  &_swigt__p_FIX__UnderlyingLegCFICode,
  &_swigt__p_FIX__UnderlyingLegMaturityDate,
  &_swigt__p_FIX__UnderlyingLegMaturityMonthYear,
  &_swigt__p_FIX__UnderlyingLegMaturityTime,
  &_swigt__p_FIX__UnderlyingLegOptAttribute,
  &_swigt__p_FIX__UnderlyingLegPutOrCall,
  &_swigt__p_FIX__UnderlyingLegSecurityAltID,
  &_swigt__p_FIX__UnderlyingLegSecurityAltIDSource,
  &_swigt__p_FIX__UnderlyingLegSecurityDesc,
  &_swigt__p_FIX__UnderlyingLegSecurityExchange,
  &_swigt__p_FIX__UnderlyingLegSecurityID,
  &_swigt__p_FIX__UnderlyingLegSecurityIDSource,
  &_swigt__p_FIX__UnderlyingLegSecuritySubType,
  &_swigt__p_FIX__UnderlyingLegSecurityType,
  &_swigt__p_FIX__UnderlyingLegStrikePrice,
  &_swigt__p_FIX__UnderlyingLegSymbol,
  &_swigt__p_FIX__UnderlyingLegSymbolSfx,
  &_swigt__p_FIX__UnderlyingLocaleOfIssue,
  &_swigt__p_FIX__UnderlyingMaturityDate,
  &_swigt__p_FIX__UnderlyingMaturityDay,
  &_swigt__p_FIX__UnderlyingMaturityMonthYear,
  &_swigt__p_FIX__UnderlyingMaturityTime,
  &_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding,
  &_swigt__p_FIX__UnderlyingOptAttribute,
  &_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding,
  &_swigt__p_FIX__UnderlyingPayAmount,
  &_swigt__p_FIX__UnderlyingPriceDeterminationMethod,
  &_swigt__p_FIX__UnderlyingPriceUnitOfMeasure,
  &_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty,
  &_swigt__p_FIX__UnderlyingProduct,
  &_swigt__p_FIX__UnderlyingPutOrCall,
  &_swigt__p_FIX__UnderlyingPx,
  &_swigt__p_FIX__UnderlyingQty,
  &_swigt__p_FIX__UnderlyingRedemptionDate,
  &_swigt__p_FIX__UnderlyingRepoCollateralSecurityType,
  &_swigt__p_FIX__UnderlyingRepurchaseRate,
  &_swigt__p_FIX__UnderlyingRepurchaseTerm,
  &_swigt__p_FIX__UnderlyingRestructuringType,
  &_swigt__p_FIX__UnderlyingSecurityAltID,
  &_swigt__p_FIX__UnderlyingSecurityAltIDSource,
  &_swigt__p_FIX__UnderlyingSecurityDesc,
  &_swigt__p_FIX__UnderlyingSecurityExchange,
  &_swigt__p_FIX__UnderlyingSecurityID,
  &_swigt__p_FIX__UnderlyingSecurityIDSource,
  &_swigt__p_FIX__UnderlyingSecuritySubType,
  &_swigt__p_FIX__UnderlyingSecurityType,
  &_swigt__p_FIX__UnderlyingSeniority,
  &_swigt__p_FIX__UnderlyingSettlMethod,
  &_swigt__p_FIX__UnderlyingSettlPrice,
  &_swigt__p_FIX__UnderlyingSettlPriceType,
  &_swigt__p_FIX__UnderlyingSettlementDate,
  &_swigt__p_FIX__UnderlyingSettlementStatus,
  &_swigt__p_FIX__UnderlyingSettlementType,
  &_swigt__p_FIX__UnderlyingStartValue,
  &_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue,
  &_swigt__p_FIX__UnderlyingStipType,
  &_swigt__p_FIX__UnderlyingStipValue,
  &_swigt__p_FIX__UnderlyingStrikeCurrency,
  &_swigt__p_FIX__UnderlyingStrikePrice,
  &_swigt__p_FIX__UnderlyingSymbol,
  &_swigt__p_FIX__UnderlyingSymbolSfx,
  &_swigt__p_FIX__UnderlyingTimeUnit,
  &_swigt__p_FIX__UnderlyingTradingSessionID,
  &_swigt__p_FIX__UnderlyingTradingSessionSubID,
  &_swigt__p_FIX__UnderlyingUnitOfMeasure,
  &_swigt__p_FIX__UnderlyingUnitOfMeasureQty,
  &_swigt__p_FIX__UndlyInstrumentPartyID,
  &_swigt__p_FIX__UndlyInstrumentPartyIDSource,
  &_swigt__p_FIX__UndlyInstrumentPartyRole,
  &_swigt__p_FIX__UndlyInstrumentPartySubID,
  &_swigt__p_FIX__UndlyInstrumentPartySubIDType,
  &_swigt__p_FIX__UnitOfMeasure,
  &_swigt__p_FIX__UnitOfMeasureQty,
  &_swigt__p_FIX__UnsolicitedIndicator,
  &_swigt__p_FIX__UnsupportedMessageType,
  &_swigt__p_FIX__UnsupportedVersion,
  &_swigt__p_FIX__Urgency,
  &_swigt__p_FIX__UserRequestID,
  &_swigt__p_FIX__UserRequestType,
  &_swigt__p_FIX__UserStatus,
  &_swigt__p_FIX__UserStatusText,
  &_swigt__p_FIX__Username,
  &_swigt__p_FIX__UtcDateField,
  &_swigt__p_FIX__UtcTimeOnlyField,
  &_swigt__p_FIX__UtcTimeStampField,
  &_swigt__p_FIX__ValidUntilTime,
  &_swigt__p_FIX__ValuationMethod,
  &_swigt__p_FIX__ValueOfFutures,
  &_swigt__p_FIX__VenueType,
  &_swigt__p_FIX__Volatility,
  &_swigt__p_FIX__WaveNo,
  &_swigt__p_FIX__WorkingIndicator,
  &_swigt__p_FIX__WtAverageLiquidity,
  &_swigt__p_FIX__XMLDATA,
  &_swigt__p_FIX__XmlData,
  &_swigt__p_FIX__XmlDataLen,
  &_swigt__p_FIX__Yield,
  &_swigt__p_FIX__YieldCalcDate,
  &_swigt__p_FIX__YieldRedemptionDate,
  &_swigt__p_FIX__YieldRedemptionPrice,
  &_swigt__p_FIX__YieldRedemptionPriceType,
  &_swigt__p_FIX__YieldType,
  &_swigt__p_Fields,
  &_swigt__p_Group,
  &_swigt__p_Groups,
  &_swigt__p_IntArray,
  &_swigt__p_IntField,
  &_swigt__p_Log,
  &_swigt__p_LogFactory,
  &_swigt__p_MessageStore,
  &_swigt__p_MessageStoreFactory,
  &_swigt__p_MsgType,
  &_swigt__p_Mutex,
  &_swigt__p_Responder,
  &_swigt__p_SessionID,
  &_swigt__p_StringField,
  &_swigt__p_TimeRange,
  &_swigt__p_UtcDate,
  &_swigt__p_UtcDateField,
  &_swigt__p_UtcTimeOnly,
  &_swigt__p_UtcTimeStamp,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_const_iterator,
  &_swigt__p_g_const_iterator,
  &_swigt__p_g_iterator,
  &_swigt__p_int,
  &_swigt__p_iterator,
  &_swigt__p_message_order,
  &_swigt__p_p_FIX__DataDictionary,
  &_swigt__p_std__istream,
  &_swigt__p_std__ostream,
  &_swigt__p_std__setTFIX__SessionID_t,
  &_swigt__p_std__string,
  &_swigt__p_std__string__size_type,
  &_swigt__p_std__vectorTstd__string_t,
};

static swig_cast_info _swigc__p_ApplVerID[] = {  {&_swigt__p_ApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Application[] = {  {&_swigt__p_Application, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BeginString[] = {  {&_swigt__p_BeginString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DOMDocumentPtr[] = {  {&_swigt__p_DOMDocumentPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Data[] = {  {&_swigt__p_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionary[] = {  {&_swigt__p_DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionaryProvider[] = {  {&_swigt__p_DataDictionaryProvider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DateTime[] = {  {&_swigt__p_DateTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dictionaries[] = {  {&_swigt__p_Dictionaries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DoubleField[] = {  {&_swigt__p_DoubleField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AMT[] = {  {&_swigt__p_FIX__AMT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Acceptor[] = {  {&_swigt__p_FIX__Acceptor, 0, 0, 0},  {&_swigt__p_FIX__SocketAcceptor, _p_FIX__SocketAcceptorTo_p_FIX__Acceptor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Account[] = {  {&_swigt__p_FIX__Account, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccountType[] = {  {&_swigt__p_FIX__AccountType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccruedInterestAmt[] = {  {&_swigt__p_FIX__AccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccruedInterestRate[] = {  {&_swigt__p_FIX__AccruedInterestRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AcctIDSource[] = {  {&_swigt__p_FIX__AcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Adjustment[] = {  {&_swigt__p_FIX__Adjustment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdjustmentType[] = {  {&_swigt__p_FIX__AdjustmentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvId[] = {  {&_swigt__p_FIX__AdvId, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvRefID[] = {  {&_swigt__p_FIX__AdvRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvSide[] = {  {&_swigt__p_FIX__AdvSide, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvTransType[] = {  {&_swigt__p_FIX__AdvTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffectedOrderID[] = {  {&_swigt__p_FIX__AffectedOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffectedSecondaryOrderID[] = {  {&_swigt__p_FIX__AffectedSecondaryOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffirmStatus[] = {  {&_swigt__p_FIX__AffirmStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AggregatedBook[] = {  {&_swigt__p_FIX__AggregatedBook, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AggressorIndicator[] = {  {&_swigt__p_FIX__AggressorIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementCurrency[] = {  {&_swigt__p_FIX__AgreementCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementDate[] = {  {&_swigt__p_FIX__AgreementDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementDesc[] = {  {&_swigt__p_FIX__AgreementDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementID[] = {  {&_swigt__p_FIX__AgreementID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccount[] = {  {&_swigt__p_FIX__AllocAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccountType[] = {  {&_swigt__p_FIX__AllocAccountType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccruedInterestAmt[] = {  {&_swigt__p_FIX__AllocAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAcctIDSource[] = {  {&_swigt__p_FIX__AllocAcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAvgPx[] = {  {&_swigt__p_FIX__AllocAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocCancReplaceReason[] = {  {&_swigt__p_FIX__AllocCancReplaceReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocClearingFeeIndicator[] = {  {&_swigt__p_FIX__AllocClearingFeeIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocCustomerCapacity[] = {  {&_swigt__p_FIX__AllocCustomerCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocHandlInst[] = {  {&_swigt__p_FIX__AllocHandlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocID[] = {  {&_swigt__p_FIX__AllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocInterestAtMaturity[] = {  {&_swigt__p_FIX__AllocInterestAtMaturity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocIntermedReqType[] = {  {&_swigt__p_FIX__AllocIntermedReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocLinkID[] = {  {&_swigt__p_FIX__AllocLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocLinkType[] = {  {&_swigt__p_FIX__AllocLinkType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocMethod[] = {  {&_swigt__p_FIX__AllocMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocNetMoney[] = {  {&_swigt__p_FIX__AllocNetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocNoOrdersType[] = {  {&_swigt__p_FIX__AllocNoOrdersType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocPositionEffect[] = {  {&_swigt__p_FIX__AllocPositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocPrice[] = {  {&_swigt__p_FIX__AllocPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocQty[] = {  {&_swigt__p_FIX__AllocQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocRejCode[] = {  {&_swigt__p_FIX__AllocRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportID[] = {  {&_swigt__p_FIX__AllocReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportRefID[] = {  {&_swigt__p_FIX__AllocReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportType[] = {  {&_swigt__p_FIX__AllocReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlCurrAmt[] = {  {&_swigt__p_FIX__AllocSettlCurrAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlCurrency[] = {  {&_swigt__p_FIX__AllocSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlInstType[] = {  {&_swigt__p_FIX__AllocSettlInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocShares[] = {  {&_swigt__p_FIX__AllocShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocStatus[] = {  {&_swigt__p_FIX__AllocStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocText[] = {  {&_swigt__p_FIX__AllocText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocTransType[] = {  {&_swigt__p_FIX__AllocTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocType[] = {  {&_swigt__p_FIX__AllocType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessCurr[] = {  {&_swigt__p_FIX__AllowableOneSidednessCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessPct[] = {  {&_swigt__p_FIX__AllowableOneSidednessPct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessValue[] = {  {&_swigt__p_FIX__AllowableOneSidednessValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AltMDSourceID[] = {  {&_swigt__p_FIX__AltMDSourceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplBegSeqNum[] = {  {&_swigt__p_FIX__ApplBegSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplEndSeqNum[] = {  {&_swigt__p_FIX__ApplEndSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplExtID[] = {  {&_swigt__p_FIX__ApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplID[] = {  {&_swigt__p_FIX__ApplID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplLastSeqNum[] = {  {&_swigt__p_FIX__ApplLastSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplNewSeqNum[] = {  {&_swigt__p_FIX__ApplNewSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueAction[] = {  {&_swigt__p_FIX__ApplQueueAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueDepth[] = {  {&_swigt__p_FIX__ApplQueueDepth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueMax[] = {  {&_swigt__p_FIX__ApplQueueMax, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueResolution[] = {  {&_swigt__p_FIX__ApplQueueResolution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReportID[] = {  {&_swigt__p_FIX__ApplReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReportType[] = {  {&_swigt__p_FIX__ApplReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReqID[] = {  {&_swigt__p_FIX__ApplReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReqType[] = {  {&_swigt__p_FIX__ApplReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResendFlag[] = {  {&_swigt__p_FIX__ApplResendFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseError[] = {  {&_swigt__p_FIX__ApplResponseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseID[] = {  {&_swigt__p_FIX__ApplResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseType[] = {  {&_swigt__p_FIX__ApplResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplSeqNum[] = {  {&_swigt__p_FIX__ApplSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplTotalMessageCount[] = {  {&_swigt__p_FIX__ApplTotalMessageCount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplVerID[] = {  {&_swigt__p_FIX__ApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Application[] = {  {&_swigt__p_FIX__Application, 0, 0, 0},  {&_swigt__p_FIX__SynchronizedApplication, _p_FIX__SynchronizedApplicationTo_p_FIX__Application, 0, 0},  {&_swigt__p_FIX__NullApplication, _p_FIX__NullApplicationTo_p_FIX__Application, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AsOfIndicator[] = {  {&_swigt__p_FIX__AsOfIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AsgnReqID[] = {  {&_swigt__p_FIX__AsgnReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AsgnRptID[] = {  {&_swigt__p_FIX__AsgnRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AssignmentMethod[] = {  {&_swigt__p_FIX__AssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AssignmentUnit[] = {  {&_swigt__p_FIX__AssignmentUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AttachmentPoint[] = {  {&_swigt__p_FIX__AttachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AutoAcceptIndicator[] = {  {&_swigt__p_FIX__AutoAcceptIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgParPx[] = {  {&_swigt__p_FIX__AvgParPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPrxPrecision[] = {  {&_swigt__p_FIX__AvgPrxPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPx[] = {  {&_swigt__p_FIX__AvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPxIndicator[] = {  {&_swigt__p_FIX__AvgPxIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPxPrecision[] = {  {&_swigt__p_FIX__AvgPxPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BOOLEAN[] = {  {&_swigt__p_FIX__BOOLEAN, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisFeatureDate[] = {  {&_swigt__p_FIX__BasisFeatureDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisFeaturePrice[] = {  {&_swigt__p_FIX__BasisFeaturePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisPxType[] = {  {&_swigt__p_FIX__BasisPxType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BeginSeqNo[] = {  {&_swigt__p_FIX__BeginSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BeginString[] = {  {&_swigt__p_FIX__BeginString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Benchmark[] = {  {&_swigt__p_FIX__Benchmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurveCurrency[] = {  {&_swigt__p_FIX__BenchmarkCurveCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurveName[] = {  {&_swigt__p_FIX__BenchmarkCurveName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurvePoint[] = {  {&_swigt__p_FIX__BenchmarkCurvePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkPrice[] = {  {&_swigt__p_FIX__BenchmarkPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkPriceType[] = {  {&_swigt__p_FIX__BenchmarkPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkSecurityID[] = {  {&_swigt__p_FIX__BenchmarkSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkSecurityIDSource[] = {  {&_swigt__p_FIX__BenchmarkSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidDescriptor[] = {  {&_swigt__p_FIX__BidDescriptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidDescriptorType[] = {  {&_swigt__p_FIX__BidDescriptorType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidForwardPoints[] = {  {&_swigt__p_FIX__BidForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidForwardPoints2[] = {  {&_swigt__p_FIX__BidForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidID[] = {  {&_swigt__p_FIX__BidID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidPx[] = {  {&_swigt__p_FIX__BidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidRequestTransType[] = {  {&_swigt__p_FIX__BidRequestTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSize[] = {  {&_swigt__p_FIX__BidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSpotRate[] = {  {&_swigt__p_FIX__BidSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSwapPoints[] = {  {&_swigt__p_FIX__BidSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidTradeType[] = {  {&_swigt__p_FIX__BidTradeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidType[] = {  {&_swigt__p_FIX__BidType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidYield[] = {  {&_swigt__p_FIX__BidYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BodyLength[] = {  {&_swigt__p_FIX__BodyLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingRefID[] = {  {&_swigt__p_FIX__BookingRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingType[] = {  {&_swigt__p_FIX__BookingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingUnit[] = {  {&_swigt__p_FIX__BookingUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BoolField[] = {  {&_swigt__p_FIX__InViewOfCommon, _p_FIX__InViewOfCommonTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PrivateQuote, _p_FIX__PrivateQuoteTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ResetSeqNumFlag, _p_FIX__ResetSeqNumFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DueToRelated, _p_FIX__DueToRelatedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AggregatedBook, _p_FIX__AggregatedBookTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LegalConfirm, _p_FIX__LegalConfirmTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ForexReq, _p_FIX__ForexReqTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__WorkingIndicator, _p_FIX__WorkingIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PublishTrdIndicator, _p_FIX__PublishTrdIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TrdRepIndicator, _p_FIX__TrdRepIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__RiskFlexibleIndicator, _p_FIX__RiskFlexibleIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DefaultVerIndicator, _p_FIX__DefaultVerIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__RefreshIndicator, _p_FIX__RefreshIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LateIndicator, _p_FIX__LateIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__FlexibleIndicator, _p_FIX__FlexibleIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AutoAcceptIndicator, _p_FIX__AutoAcceptIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__UnsolicitedIndicator, _p_FIX__UnsolicitedIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__CopyMsgIndicator, _p_FIX__CopyMsgIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskFlexibleIndicator, _p_FIX__RelationshipRiskFlexibleIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, _p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TestMessageIndicator, _p_FIX__TestMessageIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AggressorIndicator, _p_FIX__AggressorIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__FlexProductEligibilityIndicator, _p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReversalIndicator, _p_FIX__ReversalIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ContraryInstructionIndicator, _p_FIX__ContraryInstructionIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ManualOrderIndicator, _p_FIX__ManualOrderIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PriorSpreadIndicator, _p_FIX__PriorSpreadIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReportToExch, _p_FIX__ReportToExchTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__OddLot, _p_FIX__OddLotTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__IOINaturalFlag, _p_FIX__IOINaturalFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ExchangeForPhysical, _p_FIX__ExchangeForPhysicalTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LastRptRequested, _p_FIX__LastRptRequestedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__SolicitedFlag, _p_FIX__SolicitedFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TradedFlatSwitch, _p_FIX__TradedFlatSwitchTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__CustDirectedOrder, _p_FIX__CustDirectedOrderTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__BoolField, 0, 0, 0},  {&_swigt__p_FIX__LocateReqd, _p_FIX__LocateReqdTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__NotifyBrokerOfCredit, _p_FIX__NotifyBrokerOfCreditTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__MDImplicitDelete, _p_FIX__MDImplicitDeleteTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PossResend, _p_FIX__PossResendTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PossDupFlag, _p_FIX__PossDupFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PreTradeAnonymity, _p_FIX__PreTradeAnonymityTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReportedPxDiff, _p_FIX__ReportedPxDiffTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ApplResendFlag, _p_FIX__ApplResendFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PreviouslyReported, _p_FIX__PreviouslyReportedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LastFragment, _p_FIX__LastFragmentTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__GapFillFlag, _p_FIX__GapFillFlagTo_p_FIX__BoolField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BrokerOfCredit[] = {  {&_swigt__p_FIX__BrokerOfCredit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BusinessRejectReason[] = {  {&_swigt__p_FIX__BusinessRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BusinessRejectRefID[] = {  {&_swigt__p_FIX__BusinessRejectRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BuyVolume[] = {  {&_swigt__p_FIX__BuyVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CFICode[] = {  {&_swigt__p_FIX__CFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CHAR[] = {  {&_swigt__p_FIX__CHAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__COUNTRY[] = {  {&_swigt__p_FIX__COUNTRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CPProgram[] = {  {&_swigt__p_FIX__CPProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CPRegType[] = {  {&_swigt__p_FIX__CPRegType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CURRENCY[] = {  {&_swigt__p_FIX__CURRENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CalculatedCcyLastQty[] = {  {&_swigt__p_FIX__CalculatedCcyLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CancellationRights[] = {  {&_swigt__p_FIX__CancellationRights, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CapPrice[] = {  {&_swigt__p_FIX__CapPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardExpDate[] = {  {&_swigt__p_FIX__CardExpDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardHolderName[] = {  {&_swigt__p_FIX__CardHolderName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardIssNo[] = {  {&_swigt__p_FIX__CardIssNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardIssNum[] = {  {&_swigt__p_FIX__CardIssNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardNumber[] = {  {&_swigt__p_FIX__CardNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardStartDate[] = {  {&_swigt__p_FIX__CardStartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentAcctName[] = {  {&_swigt__p_FIX__CashDistribAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentAcctNumber[] = {  {&_swigt__p_FIX__CashDistribAgentAcctNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentCode[] = {  {&_swigt__p_FIX__CashDistribAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentName[] = {  {&_swigt__p_FIX__CashDistribAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribCurr[] = {  {&_swigt__p_FIX__CashDistribCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribPayRef[] = {  {&_swigt__p_FIX__CashDistribPayRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashMargin[] = {  {&_swigt__p_FIX__CashMargin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashOrderQty[] = {  {&_swigt__p_FIX__CashOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashOutstanding[] = {  {&_swigt__p_FIX__CashOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentAcctName[] = {  {&_swigt__p_FIX__CashSettlAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentAcctNum[] = {  {&_swigt__p_FIX__CashSettlAgentAcctNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentCode[] = {  {&_swigt__p_FIX__CashSettlAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentContactName[] = {  {&_swigt__p_FIX__CashSettlAgentContactName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentContactPhone[] = {  {&_swigt__p_FIX__CashSettlAgentContactPhone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentName[] = {  {&_swigt__p_FIX__CashSettlAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CcyAmt[] = {  {&_swigt__p_FIX__CcyAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CharField[] = {  {&_swigt__p_FIX__MDEntryType, _p_FIX__MDEntryTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RegistStatus, _p_FIX__RegistStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrdStatus, _p_FIX__OrdStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MatchStatus, _p_FIX__MatchStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BidTradeType, _p_FIX__BidTradeTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradeType, _p_FIX__TradeTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__FundRenewWaiv, _p_FIX__FundRenewWaivTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OpenClose, _p_FIX__OpenCloseTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Urgency, _p_FIX__UrgencyTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIOthSvc, _p_FIX__IOIOthSvcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__EmailType, _p_FIX__EmailTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AllocTransType, _p_FIX__AllocTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecTransType, _p_FIX__ExecTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BidRequestTransType, _p_FIX__BidRequestTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlObligTransType, _p_FIX__SettlObligTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ListExecInstType, _p_FIX__ListExecInstTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DlvyInstType, _p_FIX__DlvyInstTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__QuoteQualifier, _p_FIX__QuoteQualifierTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIQualifier, _p_FIX__IOIQualifierTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecType, _p_FIX__ExecTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstMode, _p_FIX__SettlInstModeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeExerciseStyle, _p_FIX__DerivativeExerciseStyleTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CharField, 0, 0, 0},  {&_swigt__p_FIX__TimeInForce, _p_FIX__TimeInForceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerType, _p_FIX__TriggerTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OwnershipType, _p_FIX__OwnershipTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AssignmentMethod, _p_FIX__AssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlMethod, _p_FIX__SettlMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, _p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__InstrmtAssignmentMethod, _p_FIX__InstrmtAssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeSettlMethod, _p_FIX__DerivativeSettlMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MDReqRejReason, _p_FIX__MDReqRejReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BookingUnit, _p_FIX__BookingUnitTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRateCalc, _p_FIX__SettlCurrFxRateCalcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRateCalc, _p_FIX__UnderlyingFXRateCalcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerAction, _p_FIX__TriggerActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DiscretionInst, _p_FIX__DiscretionInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecInstValue, _p_FIX__ExecInstValueTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceType, _p_FIX__TriggerPriceTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecPriceType, _p_FIX__ExecPriceTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlObligSource, _p_FIX__SettlObligSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MassCancelRequestType, _p_FIX__MassCancelRequestTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SubscriptionRequestType, _p_FIX__SubscriptionRequestTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceTypeScope, _p_FIX__TriggerPriceTypeScopeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ProcessCode, _p_FIX__ProcessCodeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LotType, _p_FIX__LotTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSide, _p_FIX__LegSideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceDirection, _p_FIX__TriggerPriceDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TickDirection, _p_FIX__TickDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MsgDirection, _p_FIX__MsgDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__HaltReasonChar, _p_FIX__HaltReasonCharTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrderCapacity, _p_FIX__OrderCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DealingCapacity, _p_FIX__DealingCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LastCapacity, _p_FIX__LastCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PriceProtectionScope, _p_FIX__PriceProtectionScopeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BasisPxType, _p_FIX__BasisPxTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PositionEffect, _p_FIX__PositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegPositionEffect, _p_FIX__LegPositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AllocPositionEffect, _p_FIX__AllocPositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__VenueType, _p_FIX__VenueTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__HandlInst, _p_FIX__HandlInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MoneyLaunderingStatus, _p_FIX__MoneyLaunderingStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecAckStatus, _p_FIX__ExecAckStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CxlRejResponseTo, _p_FIX__CxlRejResponseToTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DisplayWhen, _p_FIX__DisplayWhenTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrderCategory, _p_FIX__OrderCategoryTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MultiLegReportingType, _p_FIX__MultiLegReportingTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CxlType, _p_FIX__CxlTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Side, _p_FIX__SideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyIDSource, _p_FIX__RelatedContextPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, _p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RelatedPartyIDSource, _p_FIX__RelatedPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested4PartyIDSource, _p_FIX__Nested4PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RootPartyIDSource, _p_FIX__RootPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PartyAltIDSource, _p_FIX__PartyAltIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExDestinationIDSource, _p_FIX__ExDestinationIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested3PartyIDSource, _p_FIX__Nested3PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TargetPartyIDSource, _p_FIX__TargetPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyIDSource, _p_FIX__InstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstSource, _p_FIX__SettlInstSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ContextPartyIDSource, _p_FIX__ContextPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__NestedPartyIDSource, _p_FIX__NestedPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CommType, _p_FIX__CommTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PartyIDSource, _p_FIX__PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlPartyIDSource, _p_FIX__SettlPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RefOrderIDSource, _p_FIX__RefOrderIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested2PartyIDSource, _p_FIX__Nested2PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltIDSource, _p_FIX__RelatedPartyAltIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MassCancelResponse, _p_FIX__MassCancelResponseTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Benchmark, _p_FIX__BenchmarkTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerOrderType, _p_FIX__TriggerOrderTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSettlType, _p_FIX__LegSettlTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSettlmntTyp, _p_FIX__LegSettlmntTypTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlmntTyp, _p_FIX__SettlmntTypTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PreallocMethod, _p_FIX__PreallocMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExerciseMethod, _p_FIX__ExerciseMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AsOfIndicator, _p_FIX__AsOfIndicatorTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DisplayMethod, _p_FIX__DisplayMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrigTradeHandlingInstr, _p_FIX__OrigTradeHandlingInstrTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradeHandlingInstr, _p_FIX__TradeHandlingInstrTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DeleteReason, _p_FIX__DeleteReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DKReason, _p_FIX__DKReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CancellationRights, _p_FIX__CancellationRightsTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CashMargin, _p_FIX__CashMarginTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Rule80A, _p_FIX__Rule80ATo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DayBookingInst, _p_FIX__DayBookingInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AdvSide, _p_FIX__AdvSideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegOptAttribute, _p_FIX__UnderlyingLegOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OptAttribute, _p_FIX__OptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingOptAttribute, _p_FIX__UnderlyingOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIQltyInd, _p_FIX__IOIQltyIndTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegOptAttribute, _p_FIX__LegOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradSesUpdateAction, _p_FIX__TradSesUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SecurityUpdateAction, _p_FIX__SecurityUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ListUpdateAction, _p_FIX__ListUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrdType, _p_FIX__OrdTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MarketUpdateAction, _p_FIX__MarketUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MDUpdateAction, _p_FIX__MDUpdateActionTo_p_FIX__CharField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CheckSum[] = {  {&_swigt__p_FIX__CheckSum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CheckSumField[] = {  {&_swigt__p_FIX__CheckSumField, 0, 0, 0},  {&_swigt__p_FIX__CheckSum, _p_FIX__CheckSumTo_p_FIX__CheckSumField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClOrdID[] = {  {&_swigt__p_FIX__ClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClOrdLinkID[] = {  {&_swigt__p_FIX__ClOrdLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingAccount[] = {  {&_swigt__p_FIX__ClearingAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingBusinessDate[] = {  {&_swigt__p_FIX__ClearingBusinessDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingFeeIndicator[] = {  {&_swigt__p_FIX__ClearingFeeIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingFirm[] = {  {&_swigt__p_FIX__ClearingFirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingInstruction[] = {  {&_swigt__p_FIX__ClearingInstruction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClientBidID[] = {  {&_swigt__p_FIX__ClientBidID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClientID[] = {  {&_swigt__p_FIX__ClientID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAction[] = {  {&_swigt__p_FIX__CollAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollApplType[] = {  {&_swigt__p_FIX__CollApplType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnID[] = {  {&_swigt__p_FIX__CollAsgnID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnReason[] = {  {&_swigt__p_FIX__CollAsgnReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRefID[] = {  {&_swigt__p_FIX__CollAsgnRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRejectReason[] = {  {&_swigt__p_FIX__CollAsgnRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRespType[] = {  {&_swigt__p_FIX__CollAsgnRespType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnTransType[] = {  {&_swigt__p_FIX__CollAsgnTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryID[] = {  {&_swigt__p_FIX__CollInquiryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryQualifier[] = {  {&_swigt__p_FIX__CollInquiryQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryResult[] = {  {&_swigt__p_FIX__CollInquiryResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryStatus[] = {  {&_swigt__p_FIX__CollInquiryStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollReqID[] = {  {&_swigt__p_FIX__CollReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollRespID[] = {  {&_swigt__p_FIX__CollRespID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollRptID[] = {  {&_swigt__p_FIX__CollRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollStatus[] = {  {&_swigt__p_FIX__CollStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CommCurrency[] = {  {&_swigt__p_FIX__CommCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CommType[] = {  {&_swigt__p_FIX__CommType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Commission[] = {  {&_swigt__p_FIX__Commission, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventCondition[] = {  {&_swigt__p_FIX__ComplexEventCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventEndDate[] = {  {&_swigt__p_FIX__ComplexEventEndDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventEndTime[] = {  {&_swigt__p_FIX__ComplexEventEndTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPrice[] = {  {&_swigt__p_FIX__ComplexEventPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceBoundaryMethod[] = {  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceBoundaryPrecision[] = {  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceTimeType[] = {  {&_swigt__p_FIX__ComplexEventPriceTimeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventStartDate[] = {  {&_swigt__p_FIX__ComplexEventStartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventStartTime[] = {  {&_swigt__p_FIX__ComplexEventStartTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventType[] = {  {&_swigt__p_FIX__ComplexEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexOptPayoutAmount[] = {  {&_swigt__p_FIX__ComplexOptPayoutAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplianceID[] = {  {&_swigt__p_FIX__ComplianceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Concession[] = {  {&_swigt__p_FIX__Concession, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfigError[] = {  {&_swigt__p_FIX__ConfigError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmID[] = {  {&_swigt__p_FIX__ConfirmID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmRefID[] = {  {&_swigt__p_FIX__ConfirmRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmRejReason[] = {  {&_swigt__p_FIX__ConfirmRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmReqID[] = {  {&_swigt__p_FIX__ConfirmReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmStatus[] = {  {&_swigt__p_FIX__ConfirmStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmTransType[] = {  {&_swigt__p_FIX__ConfirmTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmType[] = {  {&_swigt__p_FIX__ConfirmType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtCurr[] = {  {&_swigt__p_FIX__ContAmtCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtType[] = {  {&_swigt__p_FIX__ContAmtType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtValue[] = {  {&_swigt__p_FIX__ContAmtValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContIntRptID[] = {  {&_swigt__p_FIX__ContIntRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartyID[] = {  {&_swigt__p_FIX__ContextPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartyIDSource[] = {  {&_swigt__p_FIX__ContextPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartyRole[] = {  {&_swigt__p_FIX__ContextPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartySubID[] = {  {&_swigt__p_FIX__ContextPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContextPartySubIDType[] = {  {&_swigt__p_FIX__ContextPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContingencyType[] = {  {&_swigt__p_FIX__ContingencyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraBroker[] = {  {&_swigt__p_FIX__ContraBroker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraLegRefID[] = {  {&_swigt__p_FIX__ContraLegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTradeQty[] = {  {&_swigt__p_FIX__ContraTradeQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTradeTime[] = {  {&_swigt__p_FIX__ContraTradeTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTrader[] = {  {&_swigt__p_FIX__ContraTrader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractMultiplier[] = {  {&_swigt__p_FIX__ContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractMultiplierUnit[] = {  {&_swigt__p_FIX__ContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractSettlMonth[] = {  {&_swigt__p_FIX__ContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraryInstructionIndicator[] = {  {&_swigt__p_FIX__ContraryInstructionIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CopyMsgIndicator[] = {  {&_swigt__p_FIX__CopyMsgIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CorporateAction[] = {  {&_swigt__p_FIX__CorporateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Country[] = {  {&_swigt__p_FIX__Country, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CountryOfIssue[] = {  {&_swigt__p_FIX__CountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CouponPaymentDate[] = {  {&_swigt__p_FIX__CouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CouponRate[] = {  {&_swigt__p_FIX__CouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CoveredOrUncovered[] = {  {&_swigt__p_FIX__CoveredOrUncovered, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CreditRating[] = {  {&_swigt__p_FIX__CreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossID[] = {  {&_swigt__p_FIX__CrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossPercent[] = {  {&_swigt__p_FIX__CrossPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossPrioritization[] = {  {&_swigt__p_FIX__CrossPrioritization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossType[] = {  {&_swigt__p_FIX__CrossType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CstmApplVerID[] = {  {&_swigt__p_FIX__CstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CumQty[] = {  {&_swigt__p_FIX__CumQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Currency[] = {  {&_swigt__p_FIX__Currency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CurrencyRatio[] = {  {&_swigt__p_FIX__CurrencyRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustDirectedOrder[] = {  {&_swigt__p_FIX__CustDirectedOrder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustOrderCapacity[] = {  {&_swigt__p_FIX__CustOrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustOrderHandlingInst[] = {  {&_swigt__p_FIX__CustOrderHandlingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustomerOrFirm[] = {  {&_swigt__p_FIX__CustomerOrFirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlQty[] = {  {&_swigt__p_FIX__CxlQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlRejReason[] = {  {&_swigt__p_FIX__CxlRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlRejResponseTo[] = {  {&_swigt__p_FIX__CxlRejResponseTo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlType[] = {  {&_swigt__p_FIX__CxlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DATA[] = {  {&_swigt__p_FIX__DATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DAYOFMONTH[] = {  {&_swigt__p_FIX__DAYOFMONTH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DKReason[] = {  {&_swigt__p_FIX__DKReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DataDictionary[] = {  {&_swigt__p_FIX__DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DataDictionaryNotFound[] = {  {&_swigt__p_FIX__DataDictionaryNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DateOfBirth[] = {  {&_swigt__p_FIX__DateOfBirth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DatedDate[] = {  {&_swigt__p_FIX__DatedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayAvgPx[] = {  {&_swigt__p_FIX__DayAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayBookingInst[] = {  {&_swigt__p_FIX__DayBookingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayCumQty[] = {  {&_swigt__p_FIX__DayCumQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayOrderQty[] = {  {&_swigt__p_FIX__DayOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DealingCapacity[] = {  {&_swigt__p_FIX__DealingCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefBidSize[] = {  {&_swigt__p_FIX__DefBidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefOfferSize[] = {  {&_swigt__p_FIX__DefOfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultApplExtID[] = {  {&_swigt__p_FIX__DefaultApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultApplVerID[] = {  {&_swigt__p_FIX__DefaultApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultCstmApplVerID[] = {  {&_swigt__p_FIX__DefaultCstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultVerIndicator[] = {  {&_swigt__p_FIX__DefaultVerIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeleteReason[] = {  {&_swigt__p_FIX__DeleteReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToCompID[] = {  {&_swigt__p_FIX__DeliverToCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToLocationID[] = {  {&_swigt__p_FIX__DeliverToLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToSubID[] = {  {&_swigt__p_FIX__DeliverToSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryDate[] = {  {&_swigt__p_FIX__DeliveryDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryForm[] = {  {&_swigt__p_FIX__DeliveryForm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryType[] = {  {&_swigt__p_FIX__DeliveryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivFlexProductEligibilityIndicator[] = {  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCFICode[] = {  {&_swigt__p_FIX__DerivativeCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCapPrice[] = {  {&_swigt__p_FIX__DerivativeCapPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractMultiplier[] = {  {&_swigt__p_FIX__DerivativeContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractMultiplierUnit[] = {  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractSettlMonth[] = {  {&_swigt__p_FIX__DerivativeContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCountryOfIssue[] = {  {&_swigt__p_FIX__DerivativeCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedIssuer[] = {  {&_swigt__p_FIX__DerivativeEncodedIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedIssuerLen[] = {  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedSecurityDesc[] = {  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedSecurityDescLen[] = {  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventDate[] = {  {&_swigt__p_FIX__DerivativeEventDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventPx[] = {  {&_swigt__p_FIX__DerivativeEventPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventText[] = {  {&_swigt__p_FIX__DerivativeEventText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventTime[] = {  {&_swigt__p_FIX__DerivativeEventTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventType[] = {  {&_swigt__p_FIX__DerivativeEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeExerciseStyle[] = {  {&_swigt__p_FIX__DerivativeExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFloorPrice[] = {  {&_swigt__p_FIX__DerivativeFloorPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFlowScheduleType[] = {  {&_swigt__p_FIX__DerivativeFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFuturesValuationMethod[] = {  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrAttribType[] = {  {&_swigt__p_FIX__DerivativeInstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrAttribValue[] = {  {&_swigt__p_FIX__DerivativeInstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrRegistry[] = {  {&_swigt__p_FIX__DerivativeInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrmtAssignmentMethod[] = {  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyID[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyRole[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartySubID[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeIssueDate[] = {  {&_swigt__p_FIX__DerivativeIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeIssuer[] = {  {&_swigt__p_FIX__DerivativeIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeListMethod[] = {  {&_swigt__p_FIX__DerivativeListMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeLocaleOfIssue[] = {  {&_swigt__p_FIX__DerivativeLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityDate[] = {  {&_swigt__p_FIX__DerivativeMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityMonthYear[] = {  {&_swigt__p_FIX__DerivativeMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityTime[] = {  {&_swigt__p_FIX__DerivativeMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMinPriceIncrement[] = {  {&_swigt__p_FIX__DerivativeMinPriceIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMinPriceIncrementAmount[] = {  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeNTPositionLimit[] = {  {&_swigt__p_FIX__DerivativeNTPositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeOptAttribute[] = {  {&_swigt__p_FIX__DerivativeOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeOptPayAmount[] = {  {&_swigt__p_FIX__DerivativeOptPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePositionLimit[] = {  {&_swigt__p_FIX__DerivativePositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceQuoteMethod[] = {  {&_swigt__p_FIX__DerivativePriceQuoteMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceUnitOfMeasure[] = {  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeProduct[] = {  {&_swigt__p_FIX__DerivativeProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeProductComplex[] = {  {&_swigt__p_FIX__DerivativeProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePutOrCall[] = {  {&_swigt__p_FIX__DerivativePutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityAltID[] = {  {&_swigt__p_FIX__DerivativeSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityAltIDSource[] = {  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityDesc[] = {  {&_swigt__p_FIX__DerivativeSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityExchange[] = {  {&_swigt__p_FIX__DerivativeSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityGroup[] = {  {&_swigt__p_FIX__DerivativeSecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityID[] = {  {&_swigt__p_FIX__DerivativeSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityIDSource[] = {  {&_swigt__p_FIX__DerivativeSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityListRequestType[] = {  {&_swigt__p_FIX__DerivativeSecurityListRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityStatus[] = {  {&_swigt__p_FIX__DerivativeSecurityStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecuritySubType[] = {  {&_swigt__p_FIX__DerivativeSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityType[] = {  {&_swigt__p_FIX__DerivativeSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXML[] = {  {&_swigt__p_FIX__DerivativeSecurityXML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXMLLen[] = {  {&_swigt__p_FIX__DerivativeSecurityXMLLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXMLSchema[] = {  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSettlMethod[] = {  {&_swigt__p_FIX__DerivativeSettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSettleOnOpenFlag[] = {  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeCurrency[] = {  {&_swigt__p_FIX__DerivativeStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeMultiplier[] = {  {&_swigt__p_FIX__DerivativeStrikeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikePrice[] = {  {&_swigt__p_FIX__DerivativeStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeValue[] = {  {&_swigt__p_FIX__DerivativeStrikeValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSymbol[] = {  {&_swigt__p_FIX__DerivativeSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSymbolSfx[] = {  {&_swigt__p_FIX__DerivativeSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeTimeUnit[] = {  {&_swigt__p_FIX__DerivativeTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeUnitOfMeasure[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeUnitOfMeasureQty[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeValuationMethod[] = {  {&_swigt__p_FIX__DerivativeValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Designation[] = {  {&_swigt__p_FIX__Designation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskID[] = {  {&_swigt__p_FIX__DeskID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskOrderHandlingInst[] = {  {&_swigt__p_FIX__DeskOrderHandlingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskType[] = {  {&_swigt__p_FIX__DeskType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskTypeSource[] = {  {&_swigt__p_FIX__DeskTypeSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DetachmentPoint[] = {  {&_swigt__p_FIX__DetachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Dictionary[] = {  {&_swigt__p_FIX__Dictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Dictionary__Data__const_iterator[] = {  {&_swigt__p_FIX__Dictionary__Data__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionInst[] = {  {&_swigt__p_FIX__DiscretionInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionLimitType[] = {  {&_swigt__p_FIX__DiscretionLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionMoveType[] = {  {&_swigt__p_FIX__DiscretionMoveType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffset[] = {  {&_swigt__p_FIX__DiscretionOffset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffsetType[] = {  {&_swigt__p_FIX__DiscretionOffsetType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffsetValue[] = {  {&_swigt__p_FIX__DiscretionOffsetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionPrice[] = {  {&_swigt__p_FIX__DiscretionPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionRoundDirection[] = {  {&_swigt__p_FIX__DiscretionRoundDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionScope[] = {  {&_swigt__p_FIX__DiscretionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayHighQty[] = {  {&_swigt__p_FIX__DisplayHighQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayLowQty[] = {  {&_swigt__p_FIX__DisplayLowQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayMethod[] = {  {&_swigt__p_FIX__DisplayMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayMinIncr[] = {  {&_swigt__p_FIX__DisplayMinIncr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayQty[] = {  {&_swigt__p_FIX__DisplayQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayWhen[] = {  {&_swigt__p_FIX__DisplayWhen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DistribPaymentMethod[] = {  {&_swigt__p_FIX__DistribPaymentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DistribPercentage[] = {  {&_swigt__p_FIX__DistribPercentage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DividendYield[] = {  {&_swigt__p_FIX__DividendYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DlvyInst[] = {  {&_swigt__p_FIX__DlvyInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DlvyInstType[] = {  {&_swigt__p_FIX__DlvyInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DoNotSend[] = {  {&_swigt__p_FIX__DoNotSend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DoubleField[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, _p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, _p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, _p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnitOfMeasureQty, _p_FIX__UnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, _p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, _p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasureQty, _p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasureQty, _p_FIX__LegUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLastPx, _p_FIX__UnderlyingLastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastPx, _p_FIX__LegLastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastPx, _p_FIX__LastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ReportedPx, _p_FIX__ReportedPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCapValue, _p_FIX__UnderlyingCapValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MidPx, _p_FIX__MidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayLowQty, _p_FIX__DisplayLowQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RoundingModulus, _p_FIX__RoundingModulusTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegRatioQty, _p_FIX__LegRatioQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RatioQty, _p_FIX__RatioQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntrySize, _p_FIX__MDEntrySizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexEventPrice, _p_FIX__ComplexEventPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LeavesQty, _p_FIX__LeavesQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Quantity, _p_FIX__QuantityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, _p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalTakedown, _p_FIX__TotalTakedownTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayMinIncr, _p_FIX__DisplayMinIncrTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Factor, _p_FIX__FactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingFactor, _p_FIX__UnderlyingFactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegFactor, _p_FIX__LegFactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AccruedInterestAmt, _p_FIX__AccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalAccruedInterestAmt, _p_FIX__TotalAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocAccruedInterestAmt, _p_FIX__AllocAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndAccruedInterestAmt, _p_FIX__EndAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeFloorPrice, _p_FIX__DerivativeFloorPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerPrice, _p_FIX__TriggerPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FloorPrice, _p_FIX__FloorPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RndPx, _p_FIX__RndPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ThresholdAmount, _p_FIX__ThresholdAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCashAmount, _p_FIX__UnderlyingCashAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskLimitAmount, _p_FIX__RiskLimitAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, _p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitAmount, _p_FIX__RelationshipRiskLimitAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexOptPayoutAmount, _p_FIX__ComplexOptPayoutAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCollectAmount, _p_FIX__UnderlyingCollectAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OptPayoutAmount, _p_FIX__OptPayoutAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinPriceIncrementAmount, _p_FIX__MinPriceIncrementAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDirtyPrice, _p_FIX__UnderlyingDirtyPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AvgParPx, _p_FIX__AvgParPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ShortQty, _p_FIX__ShortQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocAvgPx, _p_FIX__AllocAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerNewPrice, _p_FIX__TriggerNewPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PeggedRefPrice, _p_FIX__PeggedRefPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContraTradeQty, _p_FIX__ContraTradeQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderBookingQty, _p_FIX__OrderBookingQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingQty, _p_FIX__UnderlyingQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Commission, _p_FIX__CommissionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SharedCommission, _p_FIX__SharedCommissionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayAvgPx, _p_FIX__DayAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SpreadToBenchmark, _p_FIX__SpreadToBenchmarkTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RepurchaseRate, _p_FIX__RepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseRate, _p_FIX__UnderlyingRepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegRepurchaseRate, _p_FIX__LegRepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AttachmentPoint, _p_FIX__AttachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAttachmentPoint, _p_FIX__UnderlyingAttachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DetachmentPoint, _p_FIX__DetachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDetachmentPoint, _p_FIX__UnderlyingDetachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOptionRatio, _p_FIX__LegOptionRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MarginRatio, _p_FIX__MarginRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingEndValue, _p_FIX__UnderlyingEndValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidPx, _p_FIX__BidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplier, _p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegContractMultiplier, _p_FIX__LegContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContractMultiplier, _p_FIX__ContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeMultiplier, _p_FIX__StrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeMultiplier, _p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplier, _p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentMultiplier, _p_FIX__RelationshipRiskInstrumentMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskInstrumentMultiplier, _p_FIX__RiskInstrumentMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessValue, _p_FIX__AllowableOneSidednessValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TimeToExpiration, _p_FIX__TimeToExpirationTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints, _p_FIX__OfferForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntryForwardPoints, _p_FIX__MDEntryForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidForwardPoints, _p_FIX__BidForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSwapPoints, _p_FIX__OfferSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSwapPoints, _p_FIX__BidSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOfferForwardPoints, _p_FIX__LegOfferForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastForwardPoints, _p_FIX__LegLastForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SwapPoints, _p_FIX__SwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastForwardPoints, _p_FIX__LastForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBidForwardPoints, _p_FIX__LegBidForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastSwapPoints, _p_FIX__LastSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegGrossTradeAmt, _p_FIX__LegGrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StopPx, _p_FIX__StopPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRate, _p_FIX__UnderlyingFXRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NetChgPrevDay, _p_FIX__NetChgPrevDayTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDeliveryAmount, _p_FIX__UnderlyingDeliveryAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeOptPayAmount, _p_FIX__DerivativeOptPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPayAmount, _p_FIX__UnderlyingPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OptPayAmount, _p_FIX__OptPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CapPrice, _p_FIX__CapPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeCapPrice, _p_FIX__DerivativeCapPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferPx, _p_FIX__OfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MktOfferPx, _p_FIX__MktOfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOfferPx, _p_FIX__LegOfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferYield, _p_FIX__OfferYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Price, _p_FIX__PriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PegDifference, _p_FIX__PegDifferenceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinQty, _p_FIX__MinQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MiscFeeAmt, _p_FIX__MiscFeeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderAvgPx, _p_FIX__OrderAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastParPx, _p_FIX__LastParPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceImprovement, _p_FIX__PriceImprovementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessPct, _p_FIX__AllowableOneSidednessPctTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OutsideIndexPct, _p_FIX__OutsideIndexPctTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SellVolume, _p_FIX__SellVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PeggedPrice, _p_FIX__PeggedPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PrevClosePx, _p_FIX__PrevClosePxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndStrikePxRange, _p_FIX__EndStrikePxRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartStrikePxRange, _p_FIX__StartStrikePxRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastQty, _p_FIX__LastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCalculatedCcyLastQty, _p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastQty, _p_FIX__LegLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CalculatedCcyLastQty, _p_FIX__CalculatedCcyLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLastQty, _p_FIX__UnderlyingLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastForwardPoints2, _p_FIX__LastForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints2, _p_FIX__OfferForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidForwardPoints2, _p_FIX__BidForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPx, _p_FIX__UnderlyingPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryDisplayQty, _p_FIX__SecondaryDisplayQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayQty, _p_FIX__DisplayQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BenchmarkPrice, _p_FIX__BenchmarkPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPrice, _p_FIX__LegBenchmarkPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderQty2, _p_FIX__OrderQty2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartTickPriceRange, _p_FIX__StartTickPriceRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndTickPriceRange, _p_FIX__EndTickPriceRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionOffset, _p_FIX__DiscretionOffsetTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ParticipationRate, _p_FIX__ParticipationRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityPctLow, _p_FIX__LiquidityPctLowTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocQty, _p_FIX__AllocQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegAllocQty, _p_FIX__LegAllocQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__HighPx, _p_FIX__HighPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DoubleField, 0, 0, 0},  {&_swigt__p_FIX__FirstPx, _p_FIX__FirstPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntrySpotRate, _p_FIX__MDEntrySpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSpotRate, _p_FIX__BidSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSpotRate, _p_FIX__OfferSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastSpotRate, _p_FIX__LastSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TargetStrategyPerformance, _p_FIX__TargetStrategyPerformanceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CashOutstanding, _p_FIX__CashOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, _p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NotionalPercentageOutstanding, _p_FIX__NotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, _p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionPrice, _p_FIX__DiscretionPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPrice, _p_FIX__YieldRedemptionPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrAmt, _p_FIX__SettlCurrAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrAmt, _p_FIX__AllocSettlCurrAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Yield, _p_FIX__YieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingEndPrice, _p_FIX__UnderlyingEndPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeValue, _p_FIX__StrikeValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeValue, _p_FIX__DerivativeStrikeValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayHighQty, _p_FIX__DisplayHighQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AvgPx, _p_FIX__AvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRate, _p_FIX__SettlCurrFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrOfferFxRate, _p_FIX__SettlCurrOfferFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrBidFxRate, _p_FIX__SettlCurrBidFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, _p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MidYield, _p_FIX__MidYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidYield, _p_FIX__BidYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinTradeVol, _p_FIX__MinTradeVolTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxTradeVol, _p_FIX__MaxTradeVolTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBidPx, _p_FIX__LegBidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FillQty, _p_FIX__FillQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Spread, _p_FIX__SpreadTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndCash, _p_FIX__EndCashTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Concession, _p_FIX__ConcessionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskCouponRate, _p_FIX__RiskCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskCouponRate, _p_FIX__RelationshipRiskCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponRate, _p_FIX__UnderlyingCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastShares, _p_FIX__LastSharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CouponRate, _p_FIX__CouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCouponRate, _p_FIX__LegCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegPrice, _p_FIX__LegPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AssignmentUnit, _p_FIX__AssignmentUnitTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OutMainCntryUIndex, _p_FIX__OutMainCntryUIndexTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxShow, _p_FIX__MaxShowTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LowPx, _p_FIX__LowPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RoundLot, _p_FIX__RoundLotTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskFreeRate, _p_FIX__RiskFreeRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderCapacityQty, _p_FIX__OrderCapacityQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PctAtRisk, _p_FIX__PctAtRiskTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RefreshQty, _p_FIX__RefreshQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PosAmt, _p_FIX__PosAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MarginExcess, _p_FIX__MarginExcessTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PegOffsetValue, _p_FIX__PegOffsetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContAmtValue, _p_FIX__ContAmtValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetValue, _p_FIX__DiscretionOffsetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalNetValue, _p_FIX__TotalNetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinPriceIncrement, _p_FIX__MinPriceIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrement, _p_FIX__DerivativeMinPriceIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TickIncrement, _p_FIX__TickIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MatchIncrement, _p_FIX__MatchIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeIncrement, _p_FIX__StrikeIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DividendYield, _p_FIX__DividendYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegDividendYield, _p_FIX__LegDividendYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntryPx, _p_FIX__MDEntryPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxFloor, _p_FIX__MaxFloorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocInterestAtMaturity, _p_FIX__AllocInterestAtMaturityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__InterestAtMaturity, _p_FIX__InterestAtMaturityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxPriceVariation, _p_FIX__MaxPriceVariationTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CcyAmt, _p_FIX__CcyAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Shares, _p_FIX__SharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocShares, _p_FIX__AllocSharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EventPx, _p_FIX__EventPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeEventPx, _p_FIX__DerivativeEventPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceDelta, _p_FIX__PriceDeltaTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegVolatility, _p_FIX__LegVolatilityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Volatility, _p_FIX__VolatilityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegQty, _p_FIX__LegQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinBidSize, _p_FIX__MinBidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DefBidSize, _p_FIX__DefBidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSize, _p_FIX__BidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegStrikePrice, _p_FIX__LegStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikePrice, _p_FIX__DerivativeStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryTradingReferencePrice, _p_FIX__SecondaryTradingReferencePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TradingReferencePrice, _p_FIX__TradingReferencePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikePrice, _p_FIX__StrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikePrice, _p_FIX__UnderlyingStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegStrikePrice, _p_FIX__UnderlyingLegStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CurrencyRatio, _p_FIX__CurrencyRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCurrencyRatio, _p_FIX__LegCurrencyRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlPrice, _p_FIX__SettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPrice, _p_FIX__UnderlyingSettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriorSettlPrice, _p_FIX__PriorSettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OpenInterest, _p_FIX__OpenInterestTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DistribPercentage, _p_FIX__DistribPercentageTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ExpQty, _p_FIX__ExpQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOrderQty, _p_FIX__LegOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CashOrderQty, _p_FIX__CashOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayOrderQty, _p_FIX__DayOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderQty, _p_FIX__OrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocNetMoney, _p_FIX__AllocNetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NetMoney, _p_FIX__NetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaturityNetMoney, _p_FIX__MaturityNetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LongQty, _p_FIX__LongQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ExecPriceAdjustment, _p_FIX__ExecPriceAdjustmentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingStartValue, _p_FIX__UnderlyingStartValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrentValue, _p_FIX__UnderlyingCurrentValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinOfferSize, _p_FIX__MinOfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSize, _p_FIX__OfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DefOfferSize, _p_FIX__DefOfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FairValue, _p_FIX__FairValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CxlQty, _p_FIX__CxlQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideValue1, _p_FIX__SideValue1To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideValue2, _p_FIX__SideValue2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MktBidPx, _p_FIX__MktBidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityValue, _p_FIX__LiquidityValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartCash, _p_FIX__StartCashTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__WtAverageLiquidity, _p_FIX__WtAverageLiquidityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTraded, _p_FIX__TotalVolumeTradedTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FillPx, _p_FIX__FillPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BasisFeaturePrice, _p_FIX__BasisFeaturePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EFPTrackingError, _p_FIX__EFPTrackingErrorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerNewQty, _p_FIX__TriggerNewQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Price2, _p_FIX__Price2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, _p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, _p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryHighLimitPrice, _p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__HighLimitPrice, _p_FIX__HighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryLowLimitPrice, _p_FIX__SecondaryLowLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LowLimitPrice, _p_FIX__LowLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinLotSize, _p_FIX__MinLotSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocPrice, _p_FIX__AllocPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ValueOfFutures, _p_FIX__ValueOfFuturesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CumQty, _p_FIX__CumQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayCumQty, _p_FIX__DayCumQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityPctHigh, _p_FIX__LiquidityPctHighTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CrossPercent, _p_FIX__CrossPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskWarningLevelPercent, _p_FIX__RiskWarningLevelPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderPercent, _p_FIX__OrderPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAllocationPercent, _p_FIX__UnderlyingAllocationPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AccruedInterestRate, _p_FIX__AccruedInterestRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskWarningLevelPercent, _p_FIX__RelationshipRiskWarningLevelPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDSecSize, _p_FIX__MDSecSizeTo_p_FIX__DoubleField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DueToRelated[] = {  {&_swigt__p_FIX__DueToRelated, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DuplicateFieldNumber[] = {  {&_swigt__p_FIX__DuplicateFieldNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EFPTrackingError[] = {  {&_swigt__p_FIX__EFPTrackingError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EXCHANGE[] = {  {&_swigt__p_FIX__EXCHANGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EffectiveTime[] = {  {&_swigt__p_FIX__EffectiveTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EmailThreadID[] = {  {&_swigt__p_FIX__EmailThreadID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EmailType[] = {  {&_swigt__p_FIX__EmailType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedAllocText[] = {  {&_swigt__p_FIX__EncodedAllocText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedAllocTextLen[] = {  {&_swigt__p_FIX__EncodedAllocTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedHeadline[] = {  {&_swigt__p_FIX__EncodedHeadline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedHeadlineLen[] = {  {&_swigt__p_FIX__EncodedHeadlineLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedIssuer[] = {  {&_swigt__p_FIX__EncodedIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedIssuerLen[] = {  {&_swigt__p_FIX__EncodedIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegIssuer[] = {  {&_swigt__p_FIX__EncodedLegIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegIssuerLen[] = {  {&_swigt__p_FIX__EncodedLegIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegSecurityDesc[] = {  {&_swigt__p_FIX__EncodedLegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedLegSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListExecInst[] = {  {&_swigt__p_FIX__EncodedListExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListExecInstLen[] = {  {&_swigt__p_FIX__EncodedListExecInstLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListStatusText[] = {  {&_swigt__p_FIX__EncodedListStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListStatusTextLen[] = {  {&_swigt__p_FIX__EncodedListStatusTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedMktSegmDesc[] = {  {&_swigt__p_FIX__EncodedMktSegmDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedMktSegmDescLen[] = {  {&_swigt__p_FIX__EncodedMktSegmDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityDesc[] = {  {&_swigt__p_FIX__EncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityListDesc[] = {  {&_swigt__p_FIX__EncodedSecurityListDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityListDescLen[] = {  {&_swigt__p_FIX__EncodedSecurityListDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSubject[] = {  {&_swigt__p_FIX__EncodedSubject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSubjectLen[] = {  {&_swigt__p_FIX__EncodedSubjectLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSymbol[] = {  {&_swigt__p_FIX__EncodedSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSymbolLen[] = {  {&_swigt__p_FIX__EncodedSymbolLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedText[] = {  {&_swigt__p_FIX__EncodedText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedTextLen[] = {  {&_swigt__p_FIX__EncodedTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingIssuer[] = {  {&_swigt__p_FIX__EncodedUnderlyingIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingIssuerLen[] = {  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingSecurityDesc[] = {  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptMethod[] = {  {&_swigt__p_FIX__EncryptMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedNewPassword[] = {  {&_swigt__p_FIX__EncryptedNewPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedNewPasswordLen[] = {  {&_swigt__p_FIX__EncryptedNewPasswordLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPassword[] = {  {&_swigt__p_FIX__EncryptedPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPasswordLen[] = {  {&_swigt__p_FIX__EncryptedPasswordLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPasswordMethod[] = {  {&_swigt__p_FIX__EncryptedPasswordMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndAccruedInterestAmt[] = {  {&_swigt__p_FIX__EndAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndCash[] = {  {&_swigt__p_FIX__EndCash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndDate[] = {  {&_swigt__p_FIX__EndDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndMaturityMonthYear[] = {  {&_swigt__p_FIX__EndMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndSeqNo[] = {  {&_swigt__p_FIX__EndSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndStrikePxRange[] = {  {&_swigt__p_FIX__EndStrikePxRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndTickPriceRange[] = {  {&_swigt__p_FIX__EndTickPriceRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventDate[] = {  {&_swigt__p_FIX__EventDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventPx[] = {  {&_swigt__p_FIX__EventPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventText[] = {  {&_swigt__p_FIX__EventText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventTime[] = {  {&_swigt__p_FIX__EventTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventType[] = {  {&_swigt__p_FIX__EventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDate[] = {  {&_swigt__p_FIX__ExDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDestination[] = {  {&_swigt__p_FIX__ExDestination, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDestinationIDSource[] = {  {&_swigt__p_FIX__ExDestinationIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Exception[] = {  {&_swigt__p_FIX__RequiredTagMissing, _p_FIX__RequiredTagMissingTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidTagNumber, _p_FIX__InvalidTagNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RejectLogon, _p_FIX__RejectLogonTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectDataFormat, _p_FIX__IncorrectDataFormatTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagNotDefinedForMessage, _p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessage, _p_FIX__InvalidMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DoNotSend, _p_FIX__DoNotSendTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RuntimeError, _p_FIX__RuntimeErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__MessageParseError, _p_FIX__MessageParseErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DuplicateFieldNumber, _p_FIX__DuplicateFieldNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldNotFound, _p_FIX__FieldNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DataDictionaryNotFound, _p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SessionNotFound, _p_FIX__SessionNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__Exception, 0, 0, 0},  {&_swigt__p_FIX__IOException, _p_FIX__IOExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketException, _p_FIX__SocketExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__ConfigError, _p_FIX__ConfigErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessageType, _p_FIX__InvalidMessageTypeTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__UnsupportedMessageType, _p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__UnsupportedVersion, _p_FIX__UnsupportedVersionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectTagValue, _p_FIX__IncorrectTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__NoTagValue, _p_FIX__NoTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagOutOfOrder, _p_FIX__TagOutOfOrderTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatedTag, _p_FIX__RepeatedTagTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldConvertError, _p_FIX__FieldConvertErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectMessageStructure, _p_FIX__IncorrectMessageStructureTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatingGroupCountMismatch, _p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeForPhysical[] = {  {&_swigt__p_FIX__ExchangeForPhysical, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeRule[] = {  {&_swigt__p_FIX__ExchangeRule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeSpecialInstructions[] = {  {&_swigt__p_FIX__ExchangeSpecialInstructions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecAckStatus[] = {  {&_swigt__p_FIX__ExecAckStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecBroker[] = {  {&_swigt__p_FIX__ExecBroker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecID[] = {  {&_swigt__p_FIX__ExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecInst[] = {  {&_swigt__p_FIX__ExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecInstValue[] = {  {&_swigt__p_FIX__ExecInstValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecPriceAdjustment[] = {  {&_swigt__p_FIX__ExecPriceAdjustment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecPriceType[] = {  {&_swigt__p_FIX__ExecPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecRefID[] = {  {&_swigt__p_FIX__ExecRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecRestatementReason[] = {  {&_swigt__p_FIX__ExecRestatementReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecTransType[] = {  {&_swigt__p_FIX__ExecTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecType[] = {  {&_swigt__p_FIX__ExecType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecValuationPoint[] = {  {&_swigt__p_FIX__ExecValuationPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExerciseMethod[] = {  {&_swigt__p_FIX__ExerciseMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExerciseStyle[] = {  {&_swigt__p_FIX__ExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpQty[] = {  {&_swigt__p_FIX__ExpQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpType[] = {  {&_swigt__p_FIX__ExpType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpirationCycle[] = {  {&_swigt__p_FIX__ExpirationCycle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpirationQtyType[] = {  {&_swigt__p_FIX__ExpirationQtyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpireDate[] = {  {&_swigt__p_FIX__ExpireDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpireTime[] = {  {&_swigt__p_FIX__ExpireTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FLOAT[] = {  {&_swigt__p_FIX__FLOAT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Factor[] = {  {&_swigt__p_FIX__Factor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FairValue[] = {  {&_swigt__p_FIX__FairValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FeeMultiplier[] = {  {&_swigt__p_FIX__FeeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldBase[] = {  {&_swigt__p_FIX__CFICode, _p_FIX__CFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCFICode, _p_FIX__UnderlyingCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCFICode, _p_FIX__DerivativeCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCFICode, _p_FIX__LegCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskCFICode, _p_FIX__RiskCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskCFICode, _p_FIX__RelationshipRiskCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegCFICode, _p_FIX__UnderlyingLegCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearFormat, _p_FIX__MaturityMonthYearFormatTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartCash, _p_FIX__StartCashTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, _p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, _p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasure, _p_FIX__LegUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasure, _p_FIX__PriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnitOfMeasure, _p_FIX__UnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, _p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasure, _p_FIX__LegPriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasure, _p_FIX__DerivativeUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeID, _p_FIX__OrigTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FirmTradeID, _p_FIX__FirmTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryFirmTradeID, _p_FIX__SecondaryFirmTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeID, _p_FIX__TradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeID, _p_FIX__SecondaryTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigSecondaryTradeID, _p_FIX__OrigSecondaryTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Yield, _p_FIX__YieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityType, _p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuantityType, _p_FIX__QuantityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityType, _p_FIX__LegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityType, _p_FIX__RelationshipRiskSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QtyType, _p_FIX__QtyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityType, _p_FIX__UnderlyingSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityType, _p_FIX__SecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepoCollateralSecurityType, _p_FIX__RepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityType, _p_FIX__RiskSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepoCollateralSecurityType, _p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpirationQtyType, _p_FIX__ExpirationQtyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Account, _p_FIX__AccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingAccount, _p_FIX__ClearingAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocAccount, _p_FIX__LegAllocAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccount, _p_FIX__AllocAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDImplicitDelete, _p_FIX__MDImplicitDeleteTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegTimeUnit, _p_FIX__LegTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeUnit, _p_FIX__TimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeTimeUnit, _p_FIX__DerivativeTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTimeUnit, _p_FIX__UnderlyingTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbID, _p_FIX__StandInstDbIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotifyBrokerOfCredit, _p_FIX__NotifyBrokerOfCreditTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BrokerOfCredit, _p_FIX__BrokerOfCreditTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecuritySubType, _p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecuritySubType, _p_FIX__RiskSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecuritySubType, _p_FIX__LegSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecuritySubType, _p_FIX__DerivativeSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecuritySubType, _p_FIX__RelationshipRiskSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySubType, _p_FIX__SecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, _p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdSubType, _p_FIX__TrdSubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ShortSaleReason, _p_FIX__ShortSaleReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeleteReason, _p_FIX__DeleteReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocCancReplaceReason, _p_FIX__AllocCancReplaceReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DKReason, _p_FIX__DKReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkRequestID, _p_FIX__NetworkRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestID, _p_FIX__TradeRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserRequestID, _p_FIX__UserRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyDetailsListRequestID, _p_FIX__PartyDetailsListRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarginExcess, _p_FIX__MarginExcessTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRejReasonText, _p_FIX__RegistRejReasonTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTradeTime, _p_FIX__ContraTradeTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoEvents, _p_FIX__NoEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeEvents, _p_FIX__NoDerivativeEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CalculatedCcyLastQty, _p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastQty, _p_FIX__LastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideLastQty, _p_FIX__SideLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCalculatedCcyLastQty, _p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastQty, _p_FIX__LegLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLastQty, _p_FIX__UnderlyingLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CheckSumField, _p_FIX__CheckSumFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Username, _p_FIX__UsernameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintRptID, _p_FIX__PosMaintRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContIntRptID, _p_FIX__ContIntRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeValue, _p_FIX__DerivativeStrikeValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeValue, _p_FIX__StrikeValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayoutType, _p_FIX__OptPayoutTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedText, _p_FIX__EncodedTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GapFillFlag, _p_FIX__GapFillFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketDepth, _p_FIX__MarketDepthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StopPx, _p_FIX__StopPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDPriceLevel, _p_FIX__MDPriceLevelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteResponseLevel, _p_FIX__QuoteResponseLevelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldCalcDate, _p_FIX__YieldCalcDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollRptID, _p_FIX__CollRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegNumber, _p_FIX__LegNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosType, _p_FIX__PosTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtType, _p_FIX__ContAmtTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosAmtType, _p_FIX__PosAmtTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstID, _p_FIX__SettlInstIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportedPx, _p_FIX__ReportedPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastFragment, _p_FIX__LastFragmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceLimitType, _p_FIX__PriceLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskLimitType, _p_FIX__RiskLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegLimitType, _p_FIX__PegLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitType, _p_FIX__RelationshipRiskLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryPriceLimitType, _p_FIX__SecondaryPriceLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionLimitType, _p_FIX__DiscretionLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegStipulations, _p_FIX__NoLegStipulationsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStipulations, _p_FIX__NoStipulationsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ShortQty, _p_FIX__ShortQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SellerDays, _p_FIX__SellerDaysTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RptSeq, _p_FIX__RptSeqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetType, _p_FIX__DiscretionOffsetTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegOffsetType, _p_FIX__PegOffsetTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesEndTime, _p_FIX__TradSesEndTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventEndTime, _p_FIX__ComplexEventEndTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TierCode, _p_FIX__TierCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SpreadToBenchmark, _p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Benchmark, _p_FIX__BenchmarkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransferReason, _p_FIX__TransferReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRejectReason, _p_FIX__CollAsgnRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRequestRejectReason, _p_FIX__QuoteRequestRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SessionRejectReason, _p_FIX__SessionRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListRejectReason, _p_FIX__ListRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRejectReason, _p_FIX__QuoteRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportRejectReason, _p_FIX__TradeReportRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnRejReason, _p_FIX__StreamAsgnRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryRejectReason, _p_FIX__QuoteEntryRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecRestatementReason, _p_FIX__ExecRestatementReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdRejReason, _p_FIX__OrdRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnReason, _p_FIX__CollAsgnReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelRejectReason, _p_FIX__MassCancelRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStatusRejReason, _p_FIX__TradSesStatusRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlRejReason, _p_FIX__CxlRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmRejReason, _p_FIX__ConfirmRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionRejectReason, _p_FIX__MassActionRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrdIDReason, _p_FIX__RefOrdIDReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReqRejReason, _p_FIX__MDReqRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BusinessRejectReason, _p_FIX__BusinessRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocText, _p_FIX__AllocTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedAllocText, _p_FIX__EncodedAllocTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToSubID, _p_FIX__DeliverToSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeCurr, _p_FIX__MiscFeeCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligMsgID, _p_FIX__SettlObligMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportedPxDiff, _p_FIX__ReportedPxDiffTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEvents, _p_FIX__NoComplexEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedInstrAttrib, _p_FIX__NoNestedInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrAttrib, _p_FIX__NoInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrAttrib, _p_FIX__NoDerivativeInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrdRepIndicators, _p_FIX__NoTrdRepIndicatorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStatsIndicators, _p_FIX__NoStatsIndicatorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteSets, _p_FIX__NoQuoteSetsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BeginSeqNo, _p_FIX__BeginSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventPx, _p_FIX__EventPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventPx, _p_FIX__DerivativeEventPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityTradingEvent, _p_FIX__SecurityTradingEventTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossType, _p_FIX__CrossTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndStrikePxRange, _p_FIX__EndStrikePxRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartStrikePxRange, _p_FIX__StartStrikePxRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementDesc, _p_FIX__AgreementDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketSegmentDesc, _p_FIX__MarketSegmentDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderDelay, _p_FIX__OrderDelayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCategory, _p_FIX__OrderCategoryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsCategory, _p_FIX__NewsCategoryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinQty, _p_FIX__MinQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardNumber, _p_FIX__CardNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctNumber, _p_FIX__CashDistribAgentAcctNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPositions, _p_FIX__NoPositionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyings, _p_FIX__NoUnderlyingsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOfLegUnderlyings, _p_FIX__NoOfLegUnderlyingsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDates, _p_FIX__NoDatesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardStartDate, _p_FIX__CardStartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartDate, _p_FIX__StartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventStartDate, _p_FIX__ComplexEventStartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefreshQty, _p_FIX__RefreshQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTime, _p_FIX__OrigTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDUpdateType, _p_FIX__MDUpdateTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDQuoteType, _p_FIX__MDQuoteTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteType, _p_FIX__QuoteTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumBidders, _p_FIX__NumBiddersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementDate, _p_FIX__AgreementDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventDate, _p_FIX__EventDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, _p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentDate, _p_FIX__PaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementDate, _p_FIX__UnderlyingSettlementDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CouponPaymentDate, _p_FIX__CouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventDate, _p_FIX__DerivativeEventDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCouponPaymentDate, _p_FIX__LegCouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SymbolSfx, _p_FIX__SymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, _p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSymbolSfx, _p_FIX__RiskSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbolSfx, _p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbolSfx, _p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSymbolSfx, _p_FIX__LegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSymbolSfx, _p_FIX__RelationshipRiskSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdType, _p_FIX__TrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTrdType, _p_FIX__SecondaryTrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMsgTypes, _p_FIX__NoMsgTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerOrderType, _p_FIX__TriggerOrderTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterType, _p_FIX__StrategyParameterTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OwnerType, _p_FIX__OwnerTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlSessSubID, _p_FIX__SettlSessSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickRuleType, _p_FIX__TickRuleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFlowScheduleType, _p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFlowScheduleType, _p_FIX__LegFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFlowScheduleType, _p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlowScheduleType, _p_FIX__FlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeBasis, _p_FIX__MiscFeeBasisTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedTextLen, _p_FIX__EncodedTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedAllocTextLen, _p_FIX__EncodedAllocTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListStatusTextLen, _p_FIX__EncodedListStatusTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesEvent, _p_FIX__TradSesEventTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayQty, _p_FIX__DisplayQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryDisplayQty, _p_FIX__SecondaryDisplayQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumTradeReports, _p_FIX__TotNumTradeReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumPosReports, _p_FIX__TotalNumPosReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumReports, _p_FIX__TotNumReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumAssignmentReports, _p_FIX__TotNumAssignmentReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideSettlCurrency, _p_FIX__SideSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, _p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveCurrency, _p_FIX__BenchmarkCurveCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocSettlCurrency, _p_FIX__LegAllocSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionCurrency, _p_FIX__PositionCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrency, _p_FIX__UnderlyingCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlCurrency, _p_FIX__LegSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingCurrency, _p_FIX__TradingCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeCurrency, _p_FIX__StrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrency, _p_FIX__SettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Currency, _p_FIX__CurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCurrency, _p_FIX__LegCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideCurrency, _p_FIX__SideCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrency, _p_FIX__AllocSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementCurrency, _p_FIX__AgreementCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeCurrency, _p_FIX__DerivativeStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikeCurrency, _p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CommCurrency, _p_FIX__CommCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskLimitCurrency, _p_FIX__RiskLimitCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitCurrency, _p_FIX__RelationshipRiskLimitCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStrikeCurrency, _p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidTradeType, _p_FIX__BidTradeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeType, _p_FIX__TradeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettleOnOpenFlag, _p_FIX__SettleOnOpenFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, _p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocaleOfIssue, _p_FIX__LocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCountryOfIssue, _p_FIX__UnderlyingCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, _p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, _p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCountryOfIssue, _p_FIX__DerivativeCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, _p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCountryOfIssue, _p_FIX__LegCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLocaleOfIssue, _p_FIX__LegLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StateOrProvinceOfIssue, _p_FIX__StateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CountryOfIssue, _p_FIX__CountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeLocaleOfIssue, _p_FIX__DerivativeLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, _p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlInst, _p_FIX__NoSettlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTradingSessions, _p_FIX__NoTradingSessionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSeniority, _p_FIX__RelationshipRiskSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSeniority, _p_FIX__RiskSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSeniority, _p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Seniority, _p_FIX__SeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlQty, _p_FIX__CxlQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExecInstRules, _p_FIX__NoExecInstRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeBracket, _p_FIX__TimeBracketTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstMode, _p_FIX__SettlInstModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseError, _p_FIX__ApplResponseErrorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HaltReasonInt, _p_FIX__HaltReasonIntTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListNoOrds, _p_FIX__ListNoOrdsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlmntTyp, _p_FIX__LegSettlmntTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlmntTyp, _p_FIX__SettlmntTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvRefID, _p_FIX__AdvRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingUnit, _p_FIX__BookingUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastPx, _p_FIX__LastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastPx, _p_FIX__LegLastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLastPx, _p_FIX__UnderlyingLastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PrevClosePx, _p_FIX__PrevClosePxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReportID, _p_FIX__MDReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityReportID, _p_FIX__SecurityReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyDetailsListReportID, _p_FIX__PartyDetailsListReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportID, _p_FIX__SecondaryTradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReportID, _p_FIX__ApplReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionReportID, _p_FIX__MassActionReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketReportID, _p_FIX__MarketReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegReportID, _p_FIX__LegReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportID, _p_FIX__TradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportID, _p_FIX__AllocReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTradeReportID, _p_FIX__SideTradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegs, _p_FIX__NoLegsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CancellationRights, _p_FIX__CancellationRightsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXML, _p_FIX__SecurityXMLTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXML, _p_FIX__DerivativeSecurityXMLTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMatchRules, _p_FIX__NoMatchRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RawData, _p_FIX__RawDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocHandlInst, _p_FIX__AllocHandlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HandlInst, _p_FIX__HandlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdType, _p_FIX__OrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Factor, _p_FIX__FactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFactor, _p_FIX__UnderlyingFactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFactor, _p_FIX__LegFactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchType, _p_FIX__MatchTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIssueDate, _p_FIX__UnderlyingIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeIssueDate, _p_FIX__DerivativeIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IssueDate, _p_FIX__IssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIssueDate, _p_FIX__LegIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerType, _p_FIX__TriggerTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingAmounts, _p_FIX__NoUnderlyingAmountsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidID, _p_FIX__BidIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentSettlType, _p_FIX__RelationshipRiskInstrumentSettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlType, _p_FIX__SettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlType, _p_FIX__LegSettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskInstrumentSettlType, _p_FIX__RiskInstrumentSettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityIndType, _p_FIX__LiquidityIndTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmType, _p_FIX__ConfirmTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAvgPx, _p_FIX__AllocAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityReqID, _p_FIX__SecurityReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollApplType, _p_FIX__CollApplTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashMargin, _p_FIX__CashMarginTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPx, _p_FIX__AvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAllocationPercent, _p_FIX__UnderlyingAllocationPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskWarningLevelPercent, _p_FIX__RiskWarningLevelPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderPercent, _p_FIX__OrderPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossPercent, _p_FIX__CrossPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskWarningLevelPercent, _p_FIX__RelationshipRiskWarningLevelPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStartTime, _p_FIX__TradSesStartTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventStartTime, _p_FIX__ComplexEventStartTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListExecInstLen, _p_FIX__EncodedListExecInstLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventTime, _p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventTime, _p_FIX__EventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartyRole, _p_FIX__ContextPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyRole, _p_FIX__RootPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyRole, _p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRepPartyRole, _p_FIX__TrdRepPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyRole, _p_FIX__InstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RequestedPartyRole, _p_FIX__RequestedPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyRole, _p_FIX__Nested4PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyRole, _p_FIX__NestedPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyRole, _p_FIX__Nested3PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyRole, _p_FIX__RelatedPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, _p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyRole, _p_FIX__PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyRole, _p_FIX__RelatedContextPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyRole, _p_FIX__SettlPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyRole, _p_FIX__Nested2PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyRole, _p_FIX__TargetPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, _p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentCode, _p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentCode, _p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentCode, _p_FIX__CashSettlAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCreditRating, _p_FIX__LegCreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CreditRating, _p_FIX__CreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCreditRating, _p_FIX__UnderlyingCreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCashType, _p_FIX__UnderlyingCashTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmReqID, _p_FIX__ConfirmReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRpts, _p_FIX__NoRptsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoBidDescriptors, _p_FIX__NoBidDescriptorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegDividendYield, _p_FIX__LegDividendYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DividendYield, _p_FIX__DividendYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityResponseID, _p_FIX__SecurityResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastNetworkResponseID, _p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkResponseID, _p_FIX__NetworkResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseID, _p_FIX__ApplResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultilegModel, _p_FIX__MultilegModelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTradeQty, _p_FIX__ContraTradeQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InViewOfCommon, _p_FIX__InViewOfCommonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossPrioritization, _p_FIX__CrossPrioritizationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayLowQty, _p_FIX__DisplayLowQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RateSource, _p_FIX__RateSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListTypeSource, _p_FIX__SecurityListTypeSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligSource, _p_FIX__SettlObligSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskTypeSource, _p_FIX__DeskTypeSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCoveredOrUncovered, _p_FIX__LegCoveredOrUncoveredTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CoveredOrUncovered, _p_FIX__CoveredOrUncoveredTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteReqID, _p_FIX__QuoteReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPrice, _p_FIX__TriggerPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FloorPrice, _p_FIX__FloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFloorPrice, _p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PutOrCall, _p_FIX__PutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskPutOrCall, _p_FIX__RiskPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPutOrCall, _p_FIX__LegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegPutOrCall, _p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePutOrCall, _p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskPutOrCall, _p_FIX__RelationshipRiskPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPutOrCall, _p_FIX__UnderlyingPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctNum, _p_FIX__CashSettlAgentAcctNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, _p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbName, _p_FIX__StandInstDbNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskFreeRate, _p_FIX__RiskFreeRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRespID, _p_FIX__QuoteRespIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPrice, _p_FIX__YieldRedemptionPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionPrice, _p_FIX__DiscretionPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlType, _p_FIX__CxlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CPRegType, _p_FIX__CPRegTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCPRegType, _p_FIX__UnderlyingCPRegTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRefID, _p_FIX__CollAsgnRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExpiration, _p_FIX__NoExpirationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeToExpiration, _p_FIX__TimeToExpirationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OwnershipType, _p_FIX__OwnershipTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStipType, _p_FIX__UnderlyingStipTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceProtectionScope, _p_FIX__PriceProtectionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionScope, _p_FIX__MassActionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionScope, _p_FIX__DiscretionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResponseDestination, _p_FIX__ResponseDestinationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDestination, _p_FIX__ExDestinationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Designation, _p_FIX__DesignationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesOpenTime, _p_FIX__TradSesOpenTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingStips, _p_FIX__NoUnderlyingStipsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PeggedRefPrice, _p_FIX__PeggedRefPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOptionRatio, _p_FIX__LegOptionRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarginRatio, _p_FIX__MarginRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Urgency, _p_FIX__UrgencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentRef, _p_FIX__PaymentRefTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeForPhysical, _p_FIX__ExchangeForPhysicalTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefOfferSize, _p_FIX__DefOfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSize, _p_FIX__OfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinOfferSize, _p_FIX__MinOfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDesc, _p_FIX__EncodedMktSegmDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RFQReqID, _p_FIX__RFQReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideQty, _p_FIX__SideQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrAmt, _p_FIX__AllocSettlCurrAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrAmt, _p_FIX__SettlCurrAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__XmlData, _p_FIX__XmlDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumTickets, _p_FIX__NumTicketsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOINaturalFlag, _p_FIX__IOINaturalFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeCondition, _p_FIX__TradeConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventCondition, _p_FIX__ComplexEventConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteCondition, _p_FIX__QuoteConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidYield, _p_FIX__BidYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MidYield, _p_FIX__MidYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetGrossInd, _p_FIX__NetGrossIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecValuationPoint, _p_FIX__ExecValuationPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffectedOrderID, _p_FIX__AffectedOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderID, _p_FIX__OrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotAffectedOrderID, _p_FIX__NotAffectedOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffectedSecondaryOrderID, _p_FIX__AffectedSecondaryOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryOrderID, _p_FIX__SecondaryOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrderID, _p_FIX__RefOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReferencePage, _p_FIX__ReferencePageTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityIDSource, _p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyIDSource, _p_FIX__PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InputSource, _p_FIX__InputSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityIDSource, _p_FIX__PegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityIDSource, _p_FIX__TriggerSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityAltIDSource, _p_FIX__LegSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityAltIDSource, _p_FIX__RelationshipRiskSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyIDSource, _p_FIX__NestedPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIDSource, _p_FIX__UnderlyingIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartyIDSource, _p_FIX__ContextPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityAltIDSource, _p_FIX__SecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, _p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityIDSource, _p_FIX__SecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, _p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, _p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityAltIDSource, _p_FIX__RiskSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAltMDSource, _p_FIX__NoAltMDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityIDSource, _p_FIX__RelationshipRiskSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyIDSource, _p_FIX__RelatedContextPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MessageEventSource, _p_FIX__MessageEventSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDestinationIDSource, _p_FIX__ExDestinationIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderHandlingInstSource, _p_FIX__OrderHandlingInstSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityIDSource, _p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityIDSource, _p_FIX__DerivativeSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AcctIDSource, _p_FIX__AcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyIDSource, _p_FIX__Nested4PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityIDSource, _p_FIX__RiskSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyIDSource, _p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyAltIDSource, _p_FIX__PartyAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, _p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyIDSource, _p_FIX__Nested3PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IDSource, _p_FIX__IDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyIDSource, _p_FIX__TargetPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyIDSource, _p_FIX__InstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityIDSource, _p_FIX__LegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstSource, _p_FIX__SettlInstSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeInputSource, _p_FIX__TradeInputSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyIDSource, _p_FIX__RelatedPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAcctIDSource, _p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyIDSource, _p_FIX__SettlPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrderIDSource, _p_FIX__RefOrderIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyIDSource, _p_FIX__Nested2PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocAcctIDSource, _p_FIX__LegAllocAcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltIDSource, _p_FIX__RelatedPartyAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, _p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, _p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplTotalMessageCount, _p_FIX__ApplTotalMessageCountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FairValue, _p_FIX__FairValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterValue, _p_FIX__StrategyParameterValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegalConfirm, _p_FIX__LegalConfirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractSettlMonth, _p_FIX__ContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractSettlMonth, _p_FIX__LegContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractSettlMonth, _p_FIX__DerivativeContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteID, _p_FIX__QuoteIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransBkdTime, _p_FIX__TransBkdTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollRespID, _p_FIX__CollRespIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampType, _p_FIX__SideTrdRegTimestampTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampType, _p_FIX__TrdRegTimestampTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStipulationValue, _p_FIX__LegStipulationValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StipulationValue, _p_FIX__StipulationValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CharField, _p_FIX__CharFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MidPx, _p_FIX__MidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesMode, _p_FIX__TradSesModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Country, _p_FIX__CountryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryDate, _p_FIX__MDEntryDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Rule80A, _p_FIX__Rule80ATo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentParties, _p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentParties, _p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrumentParties, _p_FIX__NoInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LongQty, _p_FIX__LongQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSwapType, _p_FIX__LegSwapTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillQty, _p_FIX__FillQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrAttribValue, _p_FIX__InstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribValue, _p_FIX__DerivativeInstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribValue, _p_FIX__NestedInstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundingModulus, _p_FIX__RoundingModulusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocLinkType, _p_FIX__AllocLinkTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportType, _p_FIX__AllocReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportType, _p_FIX__TradeReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResponseTransportType, _p_FIX__ResponseTransportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReportType, _p_FIX__ApplReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPassword, _p_FIX__EncryptedPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Password, _p_FIX__PasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewPassword, _p_FIX__NewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyRelationship, _p_FIX__PartyRelationshipTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementType, _p_FIX__UnderlyingSettlementTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventType, _p_FIX__EventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventType, _p_FIX__ComplexEventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccountType, _p_FIX__AllocAccountTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccountType, _p_FIX__AccountTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdjustmentType, _p_FIX__AdjustmentTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventType, _p_FIX__DerivativeEventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RespondentType, _p_FIX__RespondentTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FutSettDate2, _p_FIX__FutSettDate2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceDelta, _p_FIX__PriceDeltaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValue1, _p_FIX__SideValue1To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValue2, _p_FIX__SideValue2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbol, _p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSymbol, _p_FIX__RiskSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbol, _p_FIX__UnderlyingLegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSymbol, _p_FIX__PegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSymbol, _p_FIX__LegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbol, _p_FIX__DerivativeSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSymbol, _p_FIX__RelationshipRiskSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Symbol, _p_FIX__SymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderQty2, _p_FIX__OrderQty2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AltMDSourceID, _p_FIX__AltMDSourceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoQuoteEntries, _p_FIX__TotNoQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDEntries, _p_FIX__NoMDEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotQuoteEntries, _p_FIX__TotQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteEntries, _p_FIX__NoQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__VenueType, _p_FIX__VenueTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerNewQty, _p_FIX__TriggerNewQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeInForce, _p_FIX__TimeInForceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTimeInForce, _p_FIX__SideTimeInForceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstMsgID, _p_FIX__SettlInstMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvSide, _p_FIX__AdvSideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDate2, _p_FIX__SettlDate2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigOrdModTime, _p_FIX__OrigOrdModTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueDepth, _p_FIX__ApplQueueDepthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FieldBase, 0, 0, 0},  {&_swigt__p_FIX__MatchAlgorithm, _p_FIX__MatchAlgorithmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyAltSubID, _p_FIX__PartyAltSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltSubID, _p_FIX__RelatedPartyAltSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Signature, _p_FIX__SignatureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Text, _p_FIX__TextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegInterestAccrualDate, _p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InterestAccrualDate, _p_FIX__InterestAccrualDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Pool, _p_FIX__PoolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SendingDate, _p_FIX__SendingDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistID, _p_FIX__RegistIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewSeqNo, _p_FIX__NewSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegInstrRegistry, _p_FIX__LegInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrRegistry, _p_FIX__InstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrRegistry, _p_FIX__DerivativeInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrRegistry, _p_FIX__UnderlyingInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMaturityRules, _p_FIX__NoMaturityRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeType, _p_FIX__MiscFeeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryDate, _p_FIX__DeliveryDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValidUntilTime, _p_FIX__ValidUntilTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteSetValidUntilTime, _p_FIX__QuoteSetValidUntilTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClientBidID, _p_FIX__ClientBidIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskInstrumentOperator, _p_FIX__RiskInstrumentOperatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentOperator, _p_FIX__RelationshipRiskInstrumentOperatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDesc, _p_FIX__EncodedSecurityListDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListDesc, _p_FIX__SecurityListDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ParentMktSegmID, _p_FIX__ParentMktSegmIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatsType, _p_FIX__StatsTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEventDates, _p_FIX__NoComplexEventDatesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityPctHigh, _p_FIX__LiquidityPctHighTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideReasonCd, _p_FIX__SideReasonCdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSymbol, _p_FIX__TriggerSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSymbol, _p_FIX__EncodedSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyRelationships, _p_FIX__NoPartyRelationshipsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSides, _p_FIX__NoSidesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryTime, _p_FIX__MDEntryTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportToExch, _p_FIX__ReportToExchTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Subject, _p_FIX__SubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSubject, _p_FIX__EncodedSubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeLinkID, _p_FIX__TradeLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocLinkID, _p_FIX__AllocLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBidPx, _p_FIX__LegBidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrdTypeRules, _p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLotTypeRules, _p_FIX__NoLotTypeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueMax, _p_FIX__ApplQueueMaxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FundRenewWaiv, _p_FIX__FundRenewWaivTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecPriceAdjustment, _p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Adjustment, _p_FIX__AdjustmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetSubID, _p_FIX__TargetSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceTimeType, _p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferPx, _p_FIX__OfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MktOfferPx, _p_FIX__MktOfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOfferPx, _p_FIX__LegOfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPool, _p_FIX__LegPoolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDFeedTypes, _p_FIX__NoMDFeedTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidPx, _p_FIX__BidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySpotRate, _p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSpotRate, _p_FIX__BidSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSpotRate, _p_FIX__OfferSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastSpotRate, _p_FIX__LastSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXMLSchema, _p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, _p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstCode, _p_FIX__SettlInstCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumDaysInterest, _p_FIX__NumDaysInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenInterest, _p_FIX__OpenInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValueInd, _p_FIX__SideValueIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskMaturityMonthYear, _p_FIX__RiskMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskMaturityMonthYear, _p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityMonthYear, _p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartMaturityMonthYear, _p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYear, _p_FIX__MaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityMonthYear, _p_FIX__DerivativeMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndMaturityMonthYear, _p_FIX__EndMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, _p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, _p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoIOIQualifiers, _p_FIX__NoIOIQualifiersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteQualifiers, _p_FIX__NoQuoteQualifiersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDOriginType, _p_FIX__MDOriginTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderQty, _p_FIX__OrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOrderQty, _p_FIX__LegOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashOrderQty, _p_FIX__CashOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayOrderQty, _p_FIX__DayOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeInputDevice, _p_FIX__TradeInputDeviceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderInputDevice, _p_FIX__OrderInputDeviceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoutingID, _p_FIX__RoutingIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoPartyList, _p_FIX__TotNoPartyListTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyList, _p_FIX__NoPartyListTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlOblig, _p_FIX__NoSettlObligTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityAltID, _p_FIX__RiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskSecurityAltID, _p_FIX__NoRiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskSecurityAltID, _p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltID, _p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltID, _p_FIX__DerivativeSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, _p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityAltID, _p_FIX__LegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityAltID, _p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltID, _p_FIX__RelatedPartyAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityAltID, _p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyAltID, _p_FIX__PartyAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, _p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeSecurityAltID, _p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SendingTime, _p_FIX__SendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSendingTime, _p_FIX__OnBehalfOfSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigSendingTime, _p_FIX__OrigSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopSendingTime, _p_FIX__HopSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecInst, _p_FIX__ExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListExecInst, _p_FIX__EncodedListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegExecInst, _p_FIX__LegExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListExecInst, _p_FIX__ListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLinesOfText, _p_FIX__NoLinesOfTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LinesOfText, _p_FIX__LinesOfTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDepositoryCode, _p_FIX__SettlDepositoryCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradedFlatSwitch, _p_FIX__TradedFlatSwitchTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClOrdLinkID, _p_FIX__ClOrdLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrikeRules, _p_FIX__NoStrikeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTimeInForceRules, _p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPrice, _p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPrice, _p_FIX__BenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DueToRelated, _p_FIX__DueToRelatedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DlvyInst, _p_FIX__DlvyInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccruedInterestRate, _p_FIX__AccruedInterestRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecureData, _p_FIX__SecureDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MessageEncoding, _p_FIX__MessageEncodingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpireDate, _p_FIX__ExpireDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisFeatureDate, _p_FIX__BasisFeatureDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayWhen, _p_FIX__DisplayWhenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndTickPriceRange, _p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartTickPriceRange, _p_FIX__StartTickPriceRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCompIDs, _p_FIX__NoCompIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingRefID, _p_FIX__BookingRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WtAverageLiquidity, _p_FIX__WtAverageLiquidityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceImprovement, _p_FIX__PriceImprovementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdSubTyp, _p_FIX__SideTrdSubTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinPriceIncrement, _p_FIX__MinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrement, _p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeIncrement, _p_FIX__StrikeIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchIncrement, _p_FIX__MatchIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrement, _p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickIncrement, _p_FIX__TickIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecType, _p_FIX__ExecTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MailingDtls, _p_FIX__MailingDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HaltReasonChar, _p_FIX__HaltReasonCharTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ModelType, _p_FIX__ModelTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventText, _p_FIX__EventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventText, _p_FIX__DerivativeEventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstReqRejCode, _p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocRejCode, _p_FIX__AllocRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocRejCode, _p_FIX__IndividualAllocRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerNewPrice, _p_FIX__TriggerNewPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingFirm, _p_FIX__ClearingFirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlementCycleNo, _p_FIX__SettlementCycleNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransactTime, _p_FIX__TransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TZTransactTime, _p_FIX__TZTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelSymTransactTime, _p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, _p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, _p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, _p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, _p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnitOfMeasureQty, _p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, _p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasureQty, _p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasureQty, _p_FIX__LegUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsRefID, _p_FIX__NewsRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryType, _p_FIX__MDEntryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgParPx, _p_FIX__AvgParPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQltyInd, _p_FIX__IOIQltyIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoAllocs, _p_FIX__TotNoAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegAllocs, _p_FIX__NoLegAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAllocs, _p_FIX__NoAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistDtls, _p_FIX__RegistDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRegistDtls, _p_FIX__NoRegistDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GTBookingInst, _p_FIX__GTBookingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustOrderHandlingInst, _p_FIX__CustOrderHandlingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MailingInst, _p_FIX__MailingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskOrderHandlingInst, _p_FIX__DeskOrderHandlingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayBookingInst, _p_FIX__DayBookingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPrice, _p_FIX__LegPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplVerID, _p_FIX__RefApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CstmApplVerID, _p_FIX__CstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultApplVerID, _p_FIX__DefaultApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefCstmApplVerID, _p_FIX__RefCstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplVerID, _p_FIX__ApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultCstmApplVerID, _p_FIX__DefaultCstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DateOfBirth, _p_FIX__DateOfBirthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastMsgSeqNumProcessed, _p_FIX__LastMsgSeqNumProcessedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligRefID, _p_FIX__SettlObligRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRefID, _p_FIX__LegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraLegRefID, _p_FIX__ContraLegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeLegRefID, _p_FIX__TradeLegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRateSources, _p_FIX__NoRateSourcesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotionalPercentageOutstanding, _p_FIX__NotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashOutstanding, _p_FIX__CashOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, _p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, _p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdMatchID, _p_FIX__TrdMatchIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToCompID, _p_FIX__DeliverToCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocPrice, _p_FIX__AllocPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StringField, _p_FIX__StringFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlInstType, _p_FIX__AllocSettlInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListExecInstType, _p_FIX__ListExecInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DlvyInstType, _p_FIX__DlvyInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionID, _p_FIX__TradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionID, _p_FIX__TriggerTradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionID, _p_FIX__UnderlyingTradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegScope, _p_FIX__PegScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoAccQuotes, _p_FIX__TotNoAccQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryID, _p_FIX__CollInquiryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecRefID, _p_FIX__ExecRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlRejResponseTo, _p_FIX__CxlRejResponseToTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Price, _p_FIX__PriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LotType, _p_FIX__LotTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampSrc, _p_FIX__SideTrdRegTimestampSrcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EmailType, _p_FIX__EmailTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegOptAttribute, _p_FIX__UnderlyingLegOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptAttribute, _p_FIX__OptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingOptAttribute, _p_FIX__UnderlyingOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOptAttribute, _p_FIX__LegOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlLocation, _p_FIX__SettlLocationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EffectiveTime, _p_FIX__EffectiveTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqID, _p_FIX__StreamAsgnReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsgnReqID, _p_FIX__AsgnReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteCancelType, _p_FIX__QuoteCancelTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Scope, _p_FIX__ScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpireTime, _p_FIX__ExpireTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlBrkrCode, _p_FIX__SettlBrkrCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreTradeAnonymity, _p_FIX__PreTradeAnonymityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoutingType, _p_FIX__RoutingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideMultiLegReportingType, _p_FIX__SideMultiLegReportingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingType, _p_FIX__BookingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRestructuringType, _p_FIX__UnderlyingRestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskRestructuringType, _p_FIX__RelationshipRiskRestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskRestructuringType, _p_FIX__RiskRestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultiLegReportingType, _p_FIX__MultiLegReportingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatusValue, _p_FIX__StatusValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessValue, _p_FIX__AllowableOneSidednessValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrdRegTimestamps, _p_FIX__NoTrdRegTimestampsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListID, _p_FIX__SecurityListIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListID, _p_FIX__ListIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryType, _p_FIX__DeliveryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDeliveryType, _p_FIX__SettlDeliveryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PrivateQuote, _p_FIX__PrivateQuoteTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedHeadlineLen, _p_FIX__EncodedHeadlineLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisPxType, _p_FIX__BasisPxTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityRuleID, _p_FIX__MaturityRuleIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeRuleID, _p_FIX__StrikeRuleIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteMsgID, _p_FIX__QuoteMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskType, _p_FIX__DeskTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterName, _p_FIX__StrategyParameterNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardHolderName, _p_FIX__CardHolderNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RptSys, _p_FIX__RptSysTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegQty, _p_FIX__LegQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoSecurityTypes, _p_FIX__TotNoSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumSecurityTypes, _p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDEntryTypes, _p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityTypes, _p_FIX__NoSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskWarningLevels, _p_FIX__NoRiskWarningLevelsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskWarningLevels, _p_FIX__NoRelationshipRiskWarningLevelsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxPriceLevels, _p_FIX__MaxPriceLevelsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefCompID, _p_FIX__RefCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderCompID, _p_FIX__SenderCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetCompID, _p_FIX__TargetCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopCompID, _p_FIX__HopCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfCompID, _p_FIX__OnBehalfOfCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListStatusType, _p_FIX__ListStatusTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDBookType, _p_FIX__MDBookTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSubBookType, _p_FIX__MDSubBookTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityListRequestType, _p_FIX__DerivativeSecurityListRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityRequestType, _p_FIX__SecurityRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListRequestType, _p_FIX__SecurityListRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRequestType, _p_FIX__QuoteRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListType, _p_FIX__SecurityListTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestType, _p_FIX__TradeRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserRequestType, _p_FIX__UserRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkRequestType, _p_FIX__NetworkRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SubscriptionRequestType, _p_FIX__SubscriptionRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelRequestType, _p_FIX__MassCancelRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedIssuerLen, _p_FIX__EncodedIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuerLen, _p_FIX__EncodedLegIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, _p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, _p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoRejQuotes, _p_FIX__TotNoRejQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoCxldQuotes, _p_FIX__TotNoCxldQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeProductComplex, _p_FIX__DerivativeProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProductComplex, _p_FIX__ProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskProductComplex, _p_FIX__RelationshipRiskProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskProductComplex, _p_FIX__RiskProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustOrderCapacity, _p_FIX__CustOrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigCustOrderCapacity, _p_FIX__OrigCustOrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocCustomerCapacity, _p_FIX__AllocCustomerCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastCapacity, _p_FIX__LastCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DealingCapacity, _p_FIX__DealingCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCapacity, _p_FIX__OrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityNumSecurities, _p_FIX__LiquidityNumSecuritiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumSecurities, _p_FIX__TotalNumSecuritiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistEmail, _p_FIX__RegistEmailTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplianceID, _p_FIX__ComplianceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideComplianceID, _p_FIX__SideComplianceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndSeqNo, _p_FIX__EndSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubID, _p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, _p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartySubID, _p_FIX__Nested3PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartySubID, _p_FIX__Nested4PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, _p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartySubID, _p_FIX__SettlPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartySubID, _p_FIX__PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartySubID, _p_FIX__RootPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartySubID, _p_FIX__RelatedPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubID, _p_FIX__RelatedContextPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartySubID, _p_FIX__ContextPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartySubID, _p_FIX__NestedPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartySubID, _p_FIX__Nested2PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnAckType, _p_FIX__StreamAsgnAckTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampOrigin, _p_FIX__TrdRegTimestampOriginTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribPayRef, _p_FIX__CashDistribPayRefTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistAcctType, _p_FIX__RegistAcctTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DistribPercentage, _p_FIX__DistribPercentageTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMarketSegments, _p_FIX__NoMarketSegmentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIOthSvc, _p_FIX__IOIOthSvcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeRule, _p_FIX__ExchangeRuleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReceivedDeptID, _p_FIX__ReceivedDeptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefTagID, _p_FIX__RefTagIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProgRptReqs, _p_FIX__ProgRptReqsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CcyAmt, _p_FIX__CcyAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListSeqNo, _p_FIX__ListSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LowPx, _p_FIX__LowPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustDirectedOrder, _p_FIX__CustDirectedOrderTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDStreamID, _p_FIX__MDStreamIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySize, _p_FIX__MDEntrySizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategyPerformance, _p_FIX__TargetStrategyPerformanceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoHops, _p_FIX__NoHopsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EFPTrackingError, _p_FIX__EFPTrackingErrorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MktBidPx, _p_FIX__MktBidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxFloor, _p_FIX__MaxFloorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocInterestAtMaturity, _p_FIX__AllocInterestAtMaturityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InterestAtMaturity, _p_FIX__InterestAtMaturityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideExecID, _p_FIX__SideExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryExecID, _p_FIX__SecondaryExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecID, _p_FIX__ExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Spread, _p_FIX__SpreadTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSecSizeType, _p_FIX__MDSecSizeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustomerOrFirm, _p_FIX__CustomerOrFirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, _p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen, _p_FIX__RelationshipRiskEncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, _p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDescLen, _p_FIX__EncodedMktSegmDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDescLen, _p_FIX__EncodedLegSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDescLen, _p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDescLen, _p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskEncodedSecurityDescLen, _p_FIX__RiskEncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryOriginator, _p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidDescriptorType, _p_FIX__BidDescriptorTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMiscFees, _p_FIX__NoMiscFeesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDate, _p_FIX__ExDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegMoveType, _p_FIX__PegMoveTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionMoveType, _p_FIX__DiscretionMoveTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Price2, _p_FIX__Price2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClientID, _p_FIX__ClientIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RawDataLength, _p_FIX__RawDataLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BodyLength, _p_FIX__BodyLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SignatureLength, _p_FIX__SignatureLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoClearingInstructions, _p_FIX__NoClearingInstructionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderRestrictions, _p_FIX__OrderRestrictionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeSpecialInstructions, _p_FIX__ExchangeSpecialInstructionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySeller, _p_FIX__MDEntrySellerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSecSize, _p_FIX__MDSecSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinLotSize, _p_FIX__MinLotSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDay, _p_FIX__UnderlyingMaturityDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityDay, _p_FIX__MaturityDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionResponse, _p_FIX__MassActionResponseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelResponse, _p_FIX__MassCancelResponseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideFillStationCd, _p_FIX__SideFillStationCdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocShares, _p_FIX__AllocSharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Shares, _p_FIX__SharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIShares, _p_FIX__IOISharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyListResponseTypes, _p_FIX__NoPartyListResponseTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyID, _p_FIX__Nested2PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyID, _p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyID, _p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyID, _p_FIX__UndlyInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyID, _p_FIX__TargetPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyID, _p_FIX__RelatedContextPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyID, _p_FIX__RelatedPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartyID, _p_FIX__ContextPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyID, _p_FIX__Nested4PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyID, _p_FIX__PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyID, _p_FIX__RootPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueResolution, _p_FIX__ApplQueueResolutionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayAvgPx, _p_FIX__DayAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXMLLen, _p_FIX__SecurityXMLLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLLen, _p_FIX__DerivativeSecurityXMLLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRoutingIDs, _p_FIX__NoRoutingIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryID, _p_FIX__MDEntryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryID, _p_FIX__QuoteEntryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillExecID, _p_FIX__FillExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InvestorCountryOfResidence, _p_FIX__InvestorCountryOfResidenceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefreshIndicator, _p_FIX__RefreshIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultVerIndicator, _p_FIX__DefaultVerIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeAllocIndicator, _p_FIX__TradeAllocIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskFlexibleIndicator, _p_FIX__RiskFlexibleIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRepIndicator, _p_FIX__TrdRepIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PublishTrdIndicator, _p_FIX__PublishTrdIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradePublishIndicator, _p_FIX__TradePublishIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CopyMsgIndicator, _p_FIX__CopyMsgIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ImpliedMarketIndicator, _p_FIX__ImpliedMarketIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnsolicitedIndicator, _p_FIX__UnsolicitedIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LateIndicator, _p_FIX__LateIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlexibleIndicator, _p_FIX__FlexibleIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AutoAcceptIndicator, _p_FIX__AutoAcceptIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskFlexibleIndicator, _p_FIX__RelationshipRiskFlexibleIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, _p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPxIndicator, _p_FIX__AvgPxIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TestMessageIndicator, _p_FIX__TestMessageIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WorkingIndicator, _p_FIX__WorkingIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorSpreadIndicator, _p_FIX__PriorSpreadIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ManualOrderIndicator, _p_FIX__ManualOrderIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraryInstructionIndicator, _p_FIX__ContraryInstructionIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReversalIndicator, _p_FIX__ReversalIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorityIndicator, _p_FIX__PriorityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlexProductEligibilityIndicator, _p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AggressorIndicator, _p_FIX__AggressorIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocClearingFeeIndicator, _p_FIX__AllocClearingFeeIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingFeeIndicator, _p_FIX__ClearingFeeIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsOfIndicator, _p_FIX__AsOfIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTradingSessionRules, _p_FIX__NoTradingSessionRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplID, _p_FIX__ApplIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementID, _p_FIX__AgreementIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketSegmentID, _p_FIX__MarketSegmentIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPrice, _p_FIX__ComplexEventPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraBroker, _p_FIX__ContraBrokerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecBroker, _p_FIX__ExecBrokerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRateCalc, _p_FIX__UnderlyingFXRateCalcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRateCalc, _p_FIX__SettlCurrFxRateCalcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportRefID, _p_FIX__SecondaryTradeReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintRptRefID, _p_FIX__PosMaintRptRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportRefID, _p_FIX__TradeReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportRefID, _p_FIX__AllocReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpirationCycle, _p_FIX__ExpirationCycleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResetSeqNumFlag, _p_FIX__ResetSeqNumFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPrice, _p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPrice, _p_FIX__SettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorSettlPrice, _p_FIX__PriorSettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideLiquidityInd, _p_FIX__SideLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastLiquidityInd, _p_FIX__LastLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillLiquidityInd, _p_FIX__FillLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIssuer, _p_FIX__LegIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuer, _p_FIX__EncodedUnderlyingIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeIssuer, _p_FIX__DerivativeIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIssuer, _p_FIX__UnderlyingIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuer, _p_FIX__EncodedLegIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Issuer, _p_FIX__IssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionDesc, _p_FIX__TradingSessionDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassStatusReqType, _p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqType, _p_FIX__PosReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqType, _p_FIX__StreamAsgnReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocIntermedReqType, _p_FIX__AllocIntermedReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReqType, _p_FIX__ApplReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastShares, _p_FIX__LastSharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillPx, _p_FIX__FillPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRate, _p_FIX__UnderlyingFXRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityExchange, _p_FIX__DerivativeSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, _p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityExchange, _p_FIX__SecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityExchange, _p_FIX__LegSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityExchange, _p_FIX__RelationshipRiskSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityExchange, _p_FIX__RiskSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityExchange, _p_FIX__UnderlyingSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldType, _p_FIX__YieldTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardIssNo, _p_FIX__CardIssNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingEndPrice, _p_FIX__UnderlyingEndPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocQty, _p_FIX__AllocQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocQty, _p_FIX__LegAllocQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmID, _p_FIX__ConfirmIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartySubIDType, _p_FIX__PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubIDType, _p_FIX__InstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartySubIDType, _p_FIX__RootPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, _p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartySubIDType, _p_FIX__Nested2PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, _p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, _p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartySubIDType, _p_FIX__SettlPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltSubIDType, _p_FIX__RelatedPartyAltSubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartySubIDType, _p_FIX__Nested3PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartySubIDType, _p_FIX__NestedPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartySubIDType, _p_FIX__Nested4PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyAltSubIDType, _p_FIX__PartyAltSubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedPartySubIDType, _p_FIX__RelatedPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContextPartySubIDType, _p_FIX__ContextPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubIDType, _p_FIX__RelatedContextPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SolicitedFlag, _p_FIX__SolicitedFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeAmt, _p_FIX__MiscFeeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RedemptionDate, _p_FIX__RedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeOriginationDate, _p_FIX__TradeOriginationDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRedemptionDate, _p_FIX__LegRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRedemptionDate, _p_FIX__UnderlyingRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionDate, _p_FIX__YieldRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListStatusText, _p_FIX__EncodedListStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListStatusText, _p_FIX__ListStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatusText, _p_FIX__StatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserStatusText, _p_FIX__UserStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OutsideIndexPct, _p_FIX__OutsideIndexPctTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPosAmt, _p_FIX__NoPosAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosAmt, _p_FIX__PosAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Headline, _p_FIX__HeadlineTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedHeadline, _p_FIX__EncodedHeadlineTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AttachmentPoint, _p_FIX__AttachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DetachmentPoint, _p_FIX__DetachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAttachmentPoint, _p_FIX__UnderlyingAttachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDetachmentPoint, _p_FIX__UnderlyingDetachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedDate, _p_FIX__TotalVolumeTradedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DatedDate, _p_FIX__DatedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegDatedDate, _p_FIX__LegDatedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQty, _p_FIX__IOIQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIOIQty, _p_FIX__LegIOIQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastRptRequested, _p_FIX__LastRptRequestedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponRate, _p_FIX__UnderlyingCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskCouponRate, _p_FIX__RiskCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskCouponRate, _p_FIX__RelationshipRiskCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CouponRate, _p_FIX__CouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCouponRate, _p_FIX__LegCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplID, _p_FIX__RefApplIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSideTrdRegTS, _p_FIX__NoSideTrdRegTSTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LowLimitPrice, _p_FIX__LowLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryLowLimitPrice, _p_FIX__SecondaryLowLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HighLimitPrice, _p_FIX__HighLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryHighLimitPrice, _p_FIX__SecondaryHighLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStartValue, _p_FIX__UnderlyingStartValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrentValue, _p_FIX__UnderlyingCurrentValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoApplIDs, _p_FIX__NoApplIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentName, _p_FIX__SecuritySettlAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentName, _p_FIX__CashDistribAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentName, _p_FIX__CashSettlAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRefID, _p_FIX__RegistRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BusinessRejectRefID, _p_FIX__BusinessRejectRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstRefID, _p_FIX__SettlInstRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListRefID, _p_FIX__SecurityListRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCapPrice, _p_FIX__DerivativeCapPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CapPrice, _p_FIX__CapPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IntField, _p_FIX__IntFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactPhone, _p_FIX__CashSettlAgentContactPhoneTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, _p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RejectText, _p_FIX__RejectTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundLot, _p_FIX__RoundLotTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopRefID, _p_FIX__HopRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeExerciseStyle, _p_FIX__DerivativeExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingExerciseStyle, _p_FIX__UnderlyingExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegExerciseStyle, _p_FIX__LegExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExerciseStyle, _p_FIX__ExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrikes, _p_FIX__NoStrikesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoStrikes, _p_FIX__TotNoStrikesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuer, _p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedIssuer, _p_FIX__EncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAsgnReqs, _p_FIX__NoAsgnReqsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OddLot, _p_FIX__OddLotTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CheckSum, _p_FIX__CheckSumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferYield, _p_FIX__OfferYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PeggedPrice, _p_FIX__PeggedPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingEndValue, _p_FIX__UnderlyingEndValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToLocationID, _p_FIX__DeliverToLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfLocationID, _p_FIX__OnBehalfOfLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetLocationID, _p_FIX__TargetLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocationID, _p_FIX__LocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderLocationID, _p_FIX__SenderLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__URLLink, _p_FIX__URLLinkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribCurr, _p_FIX__CashDistribCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityStatusReqID, _p_FIX__SecurityStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqID, _p_FIX__PosReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesReqID, _p_FIX__TradSesReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassStatusReqID, _p_FIX__MassStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContingencyType, _p_FIX__ContingencyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProgPeriodInterval, _p_FIX__ProgPeriodIntervalTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalTakedown, _p_FIX__TotalTakedownTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepurchaseRate, _p_FIX__LegRepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepurchaseRate, _p_FIX__RepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseRate, _p_FIX__UnderlyingRepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastParPx, _p_FIX__LastParPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDistribInsts, _p_FIX__NoDistribInstsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityPctLow, _p_FIX__LiquidityPctLowTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardIssNum, _p_FIX__CardIssNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefMsgType, _p_FIX__RefMsgTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgType, _p_FIX__MsgTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoFills, _p_FIX__NoFillsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoFills, _p_FIX__TotNoFillsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesCloseTime, _p_FIX__TradSesCloseTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesPreCloseTime, _p_FIX__TradSesPreCloseTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayHighQty, _p_FIX__DisplayHighQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidDescriptor, _p_FIX__BidDescriptorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRespType, _p_FIX__QuoteRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRespType, _p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ParticipationRate, _p_FIX__ParticipationRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecInstValue, _p_FIX__ExecInstValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegOffsetValue, _p_FIX__PegOffsetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtValue, _p_FIX__ContAmtValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetValue, _p_FIX__DiscretionOffsetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNetValue, _p_FIX__TotalNetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyAltIDs, _p_FIX__NoRelatedPartyAltIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyAltIDs, _p_FIX__NoPartyAltIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIid, _p_FIX__IOIidTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeTime, _p_FIX__StrikeTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStipValue, _p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HeartBtInt, _p_FIX__HeartBtIntTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCapValue, _p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordLen, _p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPasswordLen, _p_FIX__EncryptedNewPasswordLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeMultiplier, _p_FIX__DerivativeStrikeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplier, _p_FIX__DerivativeContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeMultiplier, _p_FIX__StrikeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplier, _p_FIX__UnderlyingContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractMultiplier, _p_FIX__LegContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractMultiplier, _p_FIX__ContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskInstrumentMultiplier, _p_FIX__RiskInstrumentMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentMultiplier, _p_FIX__RelationshipRiskInstrumentMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRejReasonCode, _p_FIX__RegistRejReasonCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ForexReq, _p_FIX__ForexReqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Side, _p_FIX__SideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDMkt, _p_FIX__MDMktTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlSessID, _p_FIX__SettlSessIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeStampField, _p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LanguageCode, _p_FIX__LanguageCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSubjectLen, _p_FIX__EncodedSubjectLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsRefType, _p_FIX__NewsRefTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedTime, _p_FIX__TotalVolumeTradedTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WaveNo, _p_FIX__WaveNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTraded, _p_FIX__TotalVolumeTradedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContraBrokers, _p_FIX__NoContraBrokersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OutMainCntryUIndex, _p_FIX__OutMainCntryUIndexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HighPx, _p_FIX__HighPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BoolField, _p_FIX__BoolFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPx, _p_FIX__UnderlyingPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsID, _p_FIX__NewsIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTrader, _p_FIX__ContraTraderTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrades, _p_FIX__NoTradesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessPct, _p_FIX__AllowableOneSidednessPctTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgSeqNum, _p_FIX__MsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplBegSeqNum, _p_FIX__ApplBegSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Volatility, _p_FIX__VolatilityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegVolatility, _p_FIX__LegVolatilityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNewsRefIDs, _p_FIX__NoNewsRefIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtCurr, _p_FIX__ContAmtCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbType, _p_FIX__StandInstDbTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingInstruction, _p_FIX__ClearingInstructionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastMkt, _p_FIX__LastMktTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityResponseType, _p_FIX__SecurityResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseType, _p_FIX__ApplResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyListResponseType, _p_FIX__PartyListResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkStatusResponseType, _p_FIX__NetworkStatusResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryAllocID, _p_FIX__SecondaryAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocID, _p_FIX__IndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefAllocID, _p_FIX__RefAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryIndividualAllocID, _p_FIX__SecondaryIndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocID, _p_FIX__LegAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIndividualAllocID, _p_FIX__LegIndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocID, _p_FIX__AllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EmailThreadID, _p_FIX__EmailThreadIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SellVolume, _p_FIX__SellVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityDesc, _p_FIX__DerivativeSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityDesc, _p_FIX__TriggerSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityDesc, _p_FIX__PegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, _p_FIX__UnderlyingLegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityDesc, _p_FIX__RelationshipRiskSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskEncodedSecurityDesc, _p_FIX__RiskEncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityDesc, _p_FIX__SecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, _p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDesc, _p_FIX__EncodedLegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc, _p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityDesc, _p_FIX__RiskSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEventTimes, _p_FIX__NoComplexEventTimesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardExpDate, _p_FIX__CardExpDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSymbolLen, _p_FIX__EncodedSymbolLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndAccruedInterestAmt, _p_FIX__EndAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalAccruedInterestAmt, _p_FIX__TotalAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccruedInterestAmt, _p_FIX__AccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccruedInterestAmt, _p_FIX__AllocAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, _p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, _p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractMultiplierUnit, _p_FIX__LegContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractMultiplierUnit, _p_FIX__ContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSide, _p_FIX__LegSideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategyParameters, _p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrategyParameters, _p_FIX__NoStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCapacities, _p_FIX__NoCapacitiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskLimits, _p_FIX__NoRiskLimitsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskLimits, _p_FIX__NoRelationshipRiskLimitsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDate, _p_FIX__UnderlyingMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityDate, _p_FIX__LegMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuantityDate, _p_FIX__QuantityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityDate, _p_FIX__UnderlyingLegMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityDate, _p_FIX__MaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgDirection, _p_FIX__MsgDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickDirection, _p_FIX__TickDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceDirection, _p_FIX__TriggerPriceDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegRoundDirection, _p_FIX__PegRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionRoundDirection, _p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PossResend, _p_FIX__PossResendTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityGroup, _p_FIX__RiskSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityGroup, _p_FIX__RelationshipRiskSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityGroup, _p_FIX__SecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RateSourceType, _p_FIX__RateSourceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrders, _p_FIX__NoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoOrders, _p_FIX__TotNoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegDifference, _p_FIX__PegDifferenceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CorporateAction, _p_FIX__CorporateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesUpdateAction, _p_FIX__TradSesUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityUpdateAction, _p_FIX__SecurityUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListUpdateAction, _p_FIX__ListUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketUpdateAction, _p_FIX__MarketUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDUpdateAction, _p_FIX__MDUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueAction, _p_FIX__ApplQueueActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionInst, _p_FIX__DiscretionInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreviouslyReported, _p_FIX__PreviouslyReportedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinTradeVol, _p_FIX__MinTradeVolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxTradeVol, _p_FIX__MaxTradeVolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessCurr, _p_FIX__AllowableOneSidednessCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityStatus, _p_FIX__SecurityStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityStatus, _p_FIX__DerivativeSecurityStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecAckStatus, _p_FIX__ExecAckStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MoneyLaunderingStatus, _p_FIX__MoneyLaunderingStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqStatus, _p_FIX__PosReqStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosQtyStatus, _p_FIX__PosQtyStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffirmStatus, _p_FIX__AffirmStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteAckStatus, _p_FIX__QuoteAckStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStatus, _p_FIX__TradSesStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryStatus, _p_FIX__CollInquiryStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryStatus, _p_FIX__QuoteEntryStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocNoOrdersType, _p_FIX__AllocNoOrdersTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplSeqNum, _p_FIX__ApplSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefSeqNum, _p_FIX__RefSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplLastSeqNum, _p_FIX__ApplLastSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplLastSeqNum, _p_FIX__RefApplLastSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplEndSeqNum, _p_FIX__ApplEndSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingQty, _p_FIX__UnderlyingQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderBookingQty, _p_FIX__OrderBookingQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCPProgram, _p_FIX__UnderlyingCPProgramTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CPProgram, _p_FIX__CPProgramTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryPx, _p_FIX__MDEntryPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvTransType, _p_FIX__AdvTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecTransType, _p_FIX__ExecTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocTransType, _p_FIX__AllocTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidRequestTransType, _p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligTransType, _p_FIX__SettlObligTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnTransType, _p_FIX__CollAsgnTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportTransType, _p_FIX__TradeReportTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmTransType, _p_FIX__ConfirmTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosTransType, _p_FIX__PosTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastForwardPoints2, _p_FIX__LastForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints2, _p_FIX__OfferForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidForwardPoints2, _p_FIX__BidForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnID, _p_FIX__CollAsgnIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenClose, _p_FIX__OpenCloseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskWarningLevelName, _p_FIX__RelationshipRiskWarningLevelNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskWarningLevelName, _p_FIX__RiskWarningLevelNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocPositionEffect, _p_FIX__AllocPositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPositionEffect, _p_FIX__LegPositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionEffect, _p_FIX__PositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, _p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedContextPartySubIDs, _p_FIX__NoRelatedContextPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRootPartySubIDs, _p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartySubIDs, _p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartySubIDs, _p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartySubIDs, _p_FIX__NoNested3PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, _p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlPartySubIDs, _p_FIX__NoSettlPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedPartySubIDs, _p_FIX__NoRelatedPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContextPartySubIDs, _p_FIX__NoContextPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrumentPartySubIDs, _p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartySubIDs, _p_FIX__NoPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IncTaxInd, _p_FIX__IncTaxIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepurchaseTerm, _p_FIX__RepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepurchaseTerm, _p_FIX__LegRepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, _p_FIX__UnderlyingRepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatdSym, _p_FIX__RelatdSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenCloseSettleFlag, _p_FIX__OpenCloseSettleFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistDetls, _p_FIX__RegistDetlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplExtID, _p_FIX__ApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultApplExtID, _p_FIX__DefaultApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplExtID, _p_FIX__RefApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRequestedPartyRoles, _p_FIX__NoRequestedPartyRolesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderSubID, _p_FIX__SenderSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligMode, _p_FIX__SettlObligModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StipulationType, _p_FIX__StipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStipulationType, _p_FIX__LegStipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionType, _p_FIX__MassActionTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TerminationType, _p_FIX__TerminationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligID, _p_FIX__SettlObligIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotAffOrigClOrdID, _p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigClOrdID, _p_FIX__OrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClOrdID, _p_FIX__ClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryClOrdID, _p_FIX__SecondaryClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentRemitterID, _p_FIX__PaymentRemitterIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidType, _p_FIX__BidTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionSubID, _p_FIX__TriggerTradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionSubID, _p_FIX__TradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, _p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketID, _p_FIX__MarketIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TaxAdvantageType, _p_FIX__TaxAdvantageTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlDetails, _p_FIX__NoSettlDetailsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RndPx, _p_FIX__RndPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayCumQty, _p_FIX__DayCumQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CumQty, _p_FIX__CumQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryPositionNo, _p_FIX__MDEntryPositionNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecPriceType, _p_FIX__ExecPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceType, _p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPriceType, _p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegPriceType, _p_FIX__PegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceType, _p_FIX__PriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPriceType, _p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuotePriceType, _p_FIX__QuotePriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPriceType, _p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPriceType, _p_FIX__SettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceType, _p_FIX__LegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPriceType, _p_FIX__BenchmarkPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAffectedOrders, _p_FIX__NoAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalAffectedOrders, _p_FIX__TotalAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNotAffectedOrders, _p_FIX__NoNotAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumberOfOrders, _p_FIX__NumberOfOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnType, _p_FIX__StreamAsgnTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyDetailsRequestResult, _p_FIX__PartyDetailsRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityRequestResult, _p_FIX__SecurityRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintResult, _p_FIX__PosMaintResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderDelayUnit, _p_FIX__OrderDelayUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerAction, _p_FIX__TriggerActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAction, _p_FIX__CollActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintAction, _p_FIX__PosMaintActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndCash, _p_FIX__EndCashTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefSubID, _p_FIX__RefSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSubID, _p_FIX__OnBehalfOfSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDirtyPrice, _p_FIX__UnderlyingDirtyPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCapacityQty, _p_FIX__OrderCapacityQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityID, _p_FIX__TriggerSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityID, _p_FIX__LegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityID, _p_FIX__SecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskSecurityID, _p_FIX__RiskSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityID, _p_FIX__UnderlyingSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityID, _p_FIX__UnderlyingLegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityID, _p_FIX__RelationshipRiskSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FinancialStatus, _p_FIX__FinancialStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementStatus, _p_FIX__UnderlyingSettlementStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchStatus, _p_FIX__MatchStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdStatus, _p_FIX__OrdStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistStatus, _p_FIX__RegistStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListOrderStatus, _p_FIX__ListOrderStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestStatus, _p_FIX__TradeRequestStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SessionStatus, _p_FIX__SessionStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecDefStatus, _p_FIX__SecDefStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserStatus, _p_FIX__UserStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRptStatus, _p_FIX__TrdRptStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderAvgPx, _p_FIX__OrderAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryRefID, _p_FIX__MDEntryRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__XmlDataLen, _p_FIX__XmlDataLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecureDataLen, _p_FIX__SecureDataLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultiLegRptTypeReq, _p_FIX__MultiLegRptTypeReqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityTime, _p_FIX__MaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityTime, _p_FIX__UnderlyingMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskMaturityTime, _p_FIX__RiskMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskMaturityTime, _p_FIX__RelationshipRiskMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityTime, _p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityTime, _p_FIX__LegMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTickRules, _p_FIX__NoTickRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingBusinessDate, _p_FIX__ClearingBusinessDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeNTPositionLimit, _p_FIX__DerivativeNTPositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionLimit, _p_FIX__PositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NTPositionLimit, _p_FIX__NTPositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePositionLimit, _p_FIX__DerivativePositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteSetID, _p_FIX__QuoteSetIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvId, _p_FIX__AdvIdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Quantity, _p_FIX__QuantityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, _p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyAltSubIDs, _p_FIX__NoPartyAltSubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyAltSubIDs, _p_FIX__NoRelatedPartyAltSubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeOptPayAmount, _p_FIX__DerivativeOptPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDeliveryAmount, _p_FIX__UnderlyingDeliveryAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPayAmount, _p_FIX__UnderlyingPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayAmount, _p_FIX__OptPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmRefID, _p_FIX__ConfirmRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskLimitPlatform, _p_FIX__RiskLimitPlatformTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitPlatform, _p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContAmts, _p_FIX__NoContAmtsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocType, _p_FIX__AllocTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SharedCommission, _p_FIX__SharedCommissionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Commission, _p_FIX__CommissionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffset, _p_FIX__DiscretionOffsetTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIRefID, _p_FIX__IOIRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisFeaturePrice, _p_FIX__BasisFeaturePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskProduct, _p_FIX__RelationshipRiskProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskProduct, _p_FIX__RiskProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegProduct, _p_FIX__LegProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeProduct, _p_FIX__DerivativeProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingProduct, _p_FIX__UnderlyingProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Product, _p_FIX__ProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocateReqd, _p_FIX__LocateReqdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Concession, _p_FIX__ConcessionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CommType, _p_FIX__CommTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxPriceVariation, _p_FIX__MaxPriceVariationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeHandlingInstr, _p_FIX__OrigTradeHandlingInstrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeHandlingInstr, _p_FIX__TradeHandlingInstrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDFeedType, _p_FIX__MDFeedTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceTypeScope, _p_FIX__TriggerPriceTypeScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestamp, _p_FIX__SideTrdRegTimestampTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestamp, _p_FIX__TrdRegTimestampTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetChgPrevDay, _p_FIX__NetChgPrevDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpQty, _p_FIX__ExpQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AssignmentUnit, _p_FIX__AssignmentUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceQuoteMethod, _p_FIX__DerivativePriceQuoteMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceQuoteMethod, _p_FIX__PriceQuoteMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreallocMethod, _p_FIX__PreallocMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExerciseMethod, _p_FIX__ExerciseMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayMethod, _p_FIX__DisplayMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollReqID, _p_FIX__CollReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesMethod, _p_FIX__TradSesMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocMethod, _p_FIX__AllocMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, _p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultilegPriceMethod, _p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryMethod, _p_FIX__StrikePriceBoundaryMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoBidComponents, _p_FIX__NoBidComponentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityValue, _p_FIX__LiquidityValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeDate, _p_FIX__OrigTradeDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeDate, _p_FIX__TradeDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListName, _p_FIX__ListNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PctAtRisk, _p_FIX__PctAtRiskTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeOnlyField, _p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoRelatedSym, _p_FIX__TotNoRelatedSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedSym, _p_FIX__NoRelatedSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, _p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReqID, _p_FIX__MDReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCurrencyRatio, _p_FIX__LegCurrencyRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CurrencyRatio, _p_FIX__CurrencyRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocNetMoney, _p_FIX__AllocNetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetMoney, _p_FIX__NetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityNetMoney, _p_FIX__MaturityNetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveName, _p_FIX__BenchmarkCurveNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveName, _p_FIX__LegBenchmarkCurveNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigPosReqRefID, _p_FIX__OrigPosReqRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RatioQty, _p_FIX__RatioQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRatioQty, _p_FIX__LegRatioQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AggregatedBook, _p_FIX__AggregatedBookTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurvePoint, _p_FIX__LegBenchmarkCurvePointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurvePoint, _p_FIX__BenchmarkCurvePointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayoutAmount, _p_FIX__OptPayoutAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCollectAmount, _p_FIX__UnderlyingCollectAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexOptPayoutAmount, _p_FIX__ComplexOptPayoutAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitAmount, _p_FIX__RelationshipRiskLimitAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ThresholdAmount, _p_FIX__ThresholdAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, _p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskLimitAmount, _p_FIX__RiskLimitAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCashAmount, _p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinPriceIncrementAmount, _p_FIX__MinPriceIncrementAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenCloseSettlFlag, _p_FIX__OpenCloseSettlFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResendFlag, _p_FIX__ApplResendFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayMinIncr, _p_FIX__DisplayMinIncrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxShow, _p_FIX__MaxShowTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExecs, _p_FIX__NoExecsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRate, _p_FIX__SettlCurrFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrOfferFxRate, _p_FIX__SettlCurrOfferFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrBidFxRate, _p_FIX__SettlCurrBidFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskID, _p_FIX__DeskIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryForm, _p_FIX__DeliveryFormTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossID, _p_FIX__CrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigCrossID, _p_FIX__OrigCrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HostCrossID, _p_FIX__HostCrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategy, _p_FIX__TargetStrategyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactName, _p_FIX__CashSettlAgentContactNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctName, _p_FIX__CashSettlAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctName, _p_FIX__CashDistribAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctName, _p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactName, _p_FIX__SecuritySettlAgentContactNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedContextPartyIDs, _p_FIX__NoRelatedContextPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartyIDs, _p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyIDs, _p_FIX__NoPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRootPartyIDs, _p_FIX__NoRootPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTargetPartyIDs, _p_FIX__NoTargetPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyIDs, _p_FIX__NoRelatedPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartyIDs, _p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartyIDs, _p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContextPartyIDs, _p_FIX__NoContextPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOfSecSizes, _p_FIX__NoOfSecSizesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FirstPx, _p_FIX__FirstPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPrxPrecision, _p_FIX__AvgPrxPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPxPrecision, _p_FIX__AvgPxPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegStrikePrice, _p_FIX__UnderlyingLegStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStrikePrice, _p_FIX__LegStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikePrice, _p_FIX__DerivativeStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradingReferencePrice, _p_FIX__SecondaryTradingReferencePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikePrice, _p_FIX__UnderlyingStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePrice, _p_FIX__StrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingReferencePrice, _p_FIX__TradingReferencePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, _p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, _p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, _p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryBuyer, _p_FIX__MDEntryBuyerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlDate, _p_FIX__LegSettlDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDate, _p_FIX__SettlDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndDate, _p_FIX__EndDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TestReqID, _p_FIX__TestReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketReqID, _p_FIX__MarketReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstReqID, _p_FIX__SettlInstReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventEndDate, _p_FIX__ComplexEventEndDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LeavesQty, _p_FIX__LeavesQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIID, _p_FIX__IOIIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribType, _p_FIX__DerivativeInstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribType, _p_FIX__NestedInstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrAttribType, _p_FIX__InstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProcessCode, _p_FIX__ProcessCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcDateField, _p_FIX__UtcDateFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DoubleField, _p_FIX__DoubleFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValueOfFutures, _p_FIX__ValueOfFuturesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteQualifier, _p_FIX__QuoteQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQualifier, _p_FIX__IOIQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryQualifier, _p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCollInquiryQualifier, _p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRiskInstruments, _p_FIX__NoRiskInstrumentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskInstruments, _p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegGrossTradeAmt, _p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinBidSize, _p_FIX__MinBidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefBidSize, _p_FIX__DefBidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSize, _p_FIX__BidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpType, _p_FIX__ExpTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastUpdateTime, _p_FIX__LastUpdateTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PossDupFlag, _p_FIX__PossDupFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlMethod, _p_FIX__UnderlyingSettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, _p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValuationMethod, _p_FIX__ValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FuturesValuationMethod, _p_FIX__FuturesValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeValuationMethod, _p_FIX__DerivativeValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AssignmentMethod, _p_FIX__AssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlMethod, _p_FIX__SettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, _p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrmtAssignmentMethod, _p_FIX__InstrmtAssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSettlMethod, _p_FIX__DerivativeSettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxMessageSize, _p_FIX__MaxMessageSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeListMethod, _p_FIX__DerivativeListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordMethod, _p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DistribPaymentMethod, _p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListMethod, _p_FIX__ListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptMethod, _p_FIX__EncryptMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceDeterminationMethod, _p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentMethod, _p_FIX__PaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, _p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastSwapPoints, _p_FIX__LastSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBidForwardPoints, _p_FIX__LegBidForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastForwardPoints, _p_FIX__LastForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SwapPoints, _p_FIX__SwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastForwardPoints, _p_FIX__LegLastForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOfferForwardPoints, _p_FIX__LegOfferForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSwapPoints, _p_FIX__BidSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSwapPoints, _p_FIX__OfferSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidForwardPoints, _p_FIX__BidForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryForwardPoints, _p_FIX__MDEntryForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints, _p_FIX__OfferForwardPointsTo_p_FIX__FieldBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldConvertError[] = {  {&_swigt__p_FIX__FieldConvertError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap[] = {  {&_swigt__p_FIX__Group, _p_FIX__GroupTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Message, _p_FIX__MessageTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__FieldMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap__Fields__const_iterator[] = {  {&_swigt__p_FIX__FieldMap__Fields__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap__Groups__const_iterator[] = {  {&_swigt__p_FIX__FieldMap__Groups__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldNotFound[] = {  {&_swigt__p_FIX__FieldNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileLog[] = {  {&_swigt__p_FIX__FileLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileLogFactory[] = {  {&_swigt__p_FIX__FileLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileStore[] = {  {&_swigt__p_FIX__FileStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileStoreFactory[] = {  {&_swigt__p_FIX__FileStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillExecID[] = {  {&_swigt__p_FIX__FillExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillLiquidityInd[] = {  {&_swigt__p_FIX__FillLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillPx[] = {  {&_swigt__p_FIX__FillPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillQty[] = {  {&_swigt__p_FIX__FillQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FinancialStatus[] = {  {&_swigt__p_FIX__FinancialStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FirmTradeID[] = {  {&_swigt__p_FIX__FirmTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FirstPx[] = {  {&_swigt__p_FIX__FirstPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlexProductEligibilityIndicator[] = {  {&_swigt__p_FIX__FlexProductEligibilityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlexibleIndicator[] = {  {&_swigt__p_FIX__FlexibleIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FloorPrice[] = {  {&_swigt__p_FIX__FloorPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlowScheduleType[] = {  {&_swigt__p_FIX__FlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ForexReq[] = {  {&_swigt__p_FIX__ForexReq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FundRenewWaiv[] = {  {&_swigt__p_FIX__FundRenewWaiv, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FutSettDate[] = {  {&_swigt__p_FIX__FutSettDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FutSettDate2[] = {  {&_swigt__p_FIX__FutSettDate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FuturesValuationMethod[] = {  {&_swigt__p_FIX__FuturesValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GTBookingInst[] = {  {&_swigt__p_FIX__GTBookingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GapFillFlag[] = {  {&_swigt__p_FIX__GapFillFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GrossTradeAmt[] = {  {&_swigt__p_FIX__GrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Group[] = {  {&_swigt__p_FIX__Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HaltReasonChar[] = {  {&_swigt__p_FIX__HaltReasonChar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HaltReasonInt[] = {  {&_swigt__p_FIX__HaltReasonInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HandlInst[] = {  {&_swigt__p_FIX__HandlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Headline[] = {  {&_swigt__p_FIX__Headline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HeartBtInt[] = {  {&_swigt__p_FIX__HeartBtInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HighLimitPrice[] = {  {&_swigt__p_FIX__HighLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HighPx[] = {  {&_swigt__p_FIX__HighPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopCompID[] = {  {&_swigt__p_FIX__HopCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopRefID[] = {  {&_swigt__p_FIX__HopRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopSendingTime[] = {  {&_swigt__p_FIX__HopSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HostCrossID[] = {  {&_swigt__p_FIX__HostCrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IDSource[] = {  {&_swigt__p_FIX__IDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__INT[] = {  {&_swigt__p_FIX__INT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOException[] = {  {&_swigt__p_FIX__IOException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIID[] = {  {&_swigt__p_FIX__IOIID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOINaturalFlag[] = {  {&_swigt__p_FIX__IOINaturalFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIOthSvc[] = {  {&_swigt__p_FIX__IOIOthSvc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQltyInd[] = {  {&_swigt__p_FIX__IOIQltyInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQty[] = {  {&_swigt__p_FIX__IOIQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQualifier[] = {  {&_swigt__p_FIX__IOIQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIRefID[] = {  {&_swigt__p_FIX__IOIRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIShares[] = {  {&_swigt__p_FIX__IOIShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOITransType[] = {  {&_swigt__p_FIX__IOITransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIid[] = {  {&_swigt__p_FIX__IOIid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ImpliedMarketIndicator[] = {  {&_swigt__p_FIX__ImpliedMarketIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InViewOfCommon[] = {  {&_swigt__p_FIX__InViewOfCommon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncTaxInd[] = {  {&_swigt__p_FIX__IncTaxInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectDataFormat[] = {  {&_swigt__p_FIX__IncorrectDataFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectMessageStructure[] = {  {&_swigt__p_FIX__IncorrectMessageStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectTagValue[] = {  {&_swigt__p_FIX__IncorrectTagValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocID[] = {  {&_swigt__p_FIX__IndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocRejCode[] = {  {&_swigt__p_FIX__IndividualAllocRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocType[] = {  {&_swigt__p_FIX__IndividualAllocType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Initiator[] = {  {&_swigt__p_FIX__Initiator, 0, 0, 0},  {&_swigt__p_FIX__SocketInitiator, _p_FIX__SocketInitiatorTo_p_FIX__Initiator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InputSource[] = {  {&_swigt__p_FIX__InputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrAttribType[] = {  {&_swigt__p_FIX__InstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrAttribValue[] = {  {&_swigt__p_FIX__InstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrRegistry[] = {  {&_swigt__p_FIX__InstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrmtAssignmentMethod[] = {  {&_swigt__p_FIX__InstrmtAssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyID[] = {  {&_swigt__p_FIX__InstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyIDSource[] = {  {&_swigt__p_FIX__InstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyRole[] = {  {&_swigt__p_FIX__InstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartySubID[] = {  {&_swigt__p_FIX__InstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartySubIDType[] = {  {&_swigt__p_FIX__InstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IntField[] = {  {&_swigt__p_FIX__NoNewsRefIDs, _p_FIX__NoNewsRefIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPositions, _p_FIX__NoPositionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskWarningLevels, _p_FIX__NoRelationshipRiskWarningLevelsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaxPriceLevels, _p_FIX__MaxPriceLevelsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRiskWarningLevels, _p_FIX__NoRiskWarningLevelsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMiscFees, _p_FIX__NoMiscFeesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ClearingInstruction, _p_FIX__ClearingInstructionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEventTimes, _p_FIX__NoComplexEventTimesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDSecSizeType, _p_FIX__MDSecSizeTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RepurchaseTerm, _p_FIX__RepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegRepurchaseTerm, _p_FIX__LegRepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, _p_FIX__UnderlyingRepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RptSeq, _p_FIX__RptSeqTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumBidders, _p_FIX__NumBiddersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultilegModel, _p_FIX__MultilegModelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDPriceLevel, _p_FIX__MDPriceLevelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteResponseLevel, _p_FIX__QuoteResponseLevelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventCondition, _p_FIX__ComplexEventConditionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OptPayoutType, _p_FIX__OptPayoutTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideValueInd, _p_FIX__SideValueIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContAmts, _p_FIX__NoContAmtsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContractMultiplierUnit, _p_FIX__ContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegContractMultiplierUnit, _p_FIX__LegContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, _p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, _p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskInstruments, _p_FIX__NoRelationshipRiskInstrumentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRiskInstruments, _p_FIX__NoRiskInstrumentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplEndSeqNum, _p_FIX__ApplEndSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefApplLastSeqNum, _p_FIX__RefApplLastSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplLastSeqNum, _p_FIX__ApplLastSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefSeqNum, _p_FIX__RefSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplSeqNum, _p_FIX__ApplSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MsgSeqNum, _p_FIX__MsgSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplBegSeqNum, _p_FIX__ApplBegSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExecInstRules, _p_FIX__NoExecInstRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoQuoteEntries, _p_FIX__TotNoQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDEntries, _p_FIX__NoMDEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotQuoteEntries, _p_FIX__TotQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteEntries, _p_FIX__NoQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HopRefID, _p_FIX__HopRefIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SessionRejectReason, _p_FIX__SessionRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListRejectReason, _p_FIX__ListRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionRejectReason, _p_FIX__MassActionRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmRejReason, _p_FIX__ConfirmRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CxlRejReason, _p_FIX__CxlRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnRejReason, _p_FIX__StreamAsgnRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteEntryRejectReason, _p_FIX__QuoteEntryRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrdRejReason, _p_FIX__OrdRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExecRestatementReason, _p_FIX__ExecRestatementReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportRejectReason, _p_FIX__TradeReportRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRejectReason, _p_FIX__QuoteRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnReason, _p_FIX__CollAsgnReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassCancelRejectReason, _p_FIX__MassCancelRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesStatusRejReason, _p_FIX__TradSesStatusRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRequestRejectReason, _p_FIX__QuoteRequestRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnRejectReason, _p_FIX__CollAsgnRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefOrdIDReason, _p_FIX__RefOrdIDReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BusinessRejectReason, _p_FIX__BusinessRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContraBrokers, _p_FIX__NoContraBrokersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocCancReplaceReason, _p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ShortSaleReason, _p_FIX__ShortSaleReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlementCycleNo, _p_FIX__SettlementCycleNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrdRegTimestamps, _p_FIX__NoTrdRegTimestampsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAffectedOrders, _p_FIX__NoAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalAffectedOrders, _p_FIX__TotalAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNotAffectedOrders, _p_FIX__NoNotAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumberOfOrders, _p_FIX__NumberOfOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoOrders, _p_FIX__TotNoOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOrders, _p_FIX__NoOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoApplIDs, _p_FIX__NoApplIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueResolution, _p_FIX__ApplQueueResolutionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPrxPrecision, _p_FIX__AvgPrxPrecisionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPxPrecision, _p_FIX__AvgPxPrecisionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Adjustment, _p_FIX__AdjustmentTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RegistRejReasonCode, _p_FIX__RegistRejReasonCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MiscFeeBasis, _p_FIX__MiscFeeBasisTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListStatusType, _p_FIX__ListStatusTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteSets, _p_FIX__NoQuoteSetsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpType, _p_FIX__ExpTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedIssuerLen, _p_FIX__EncodedIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuerLen, _p_FIX__EncodedLegIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, _p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, _p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeliveryForm, _p_FIX__DeliveryFormTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegLimitType, _p_FIX__PegLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionLimitType, _p_FIX__DiscretionLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecondaryPriceLimitType, _p_FIX__SecondaryPriceLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitType, _p_FIX__RelationshipRiskLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskLimitType, _p_FIX__RiskLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriceLimitType, _p_FIX__PriceLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentOperator, _p_FIX__RelationshipRiskInstrumentOperatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskInstrumentOperator, _p_FIX__RiskInstrumentOperatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskProduct, _p_FIX__RelationshipRiskProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskProduct, _p_FIX__RiskProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegProduct, _p_FIX__LegProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeProduct, _p_FIX__DerivativeProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingProduct, _p_FIX__UnderlyingProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Product, _p_FIX__ProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTradingSessions, _p_FIX__NoTradingSessionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IncTaxInd, _p_FIX__IncTaxIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCapacities, _p_FIX__NoCapacitiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPriceType, _p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegPriceType, _p_FIX__PegPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriceType, _p_FIX__PriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPriceType, _p_FIX__YieldRedemptionPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuotePriceType, _p_FIX__QuotePriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPriceType, _p_FIX__LegBenchmarkPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPriceType, _p_FIX__SettlPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegPriceType, _p_FIX__LegPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BenchmarkPriceType, _p_FIX__BenchmarkPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampType, _p_FIX__TrdRegTimestampTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampType, _p_FIX__SideTrdRegTimestampTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RateSourceType, _p_FIX__RateSourceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionType, _p_FIX__MassActionTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TerminationType, _p_FIX__TerminationTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSecurityAltID, _p_FIX__NoSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, _p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeSecurityAltID, _p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskSecurityAltID, _p_FIX__NoRelationshipRiskSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRiskSecurityAltID, _p_FIX__NoRiskSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAsgnReqs, _p_FIX__NoAsgnReqsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMatchRules, _p_FIX__NoMatchRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityListRequestType, _p_FIX__DerivativeSecurityListRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityRequestType, _p_FIX__SecurityRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestType, _p_FIX__TradeRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UserRequestType, _p_FIX__UserRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetworkRequestType, _p_FIX__NetworkRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListType, _p_FIX__SecurityListTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRequestType, _p_FIX__QuoteRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListRequestType, _p_FIX__SecurityListRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HeartBtInt, _p_FIX__HeartBtIntTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StatsType, _p_FIX__StatsTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocSettlInstType, _p_FIX__AllocSettlInstTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskPutOrCall, _p_FIX__RiskPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegPutOrCall, _p_FIX__LegPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegPutOrCall, _p_FIX__UnderlyingLegPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativePutOrCall, _p_FIX__DerivativePutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PutOrCall, _p_FIX__PutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskPutOrCall, _p_FIX__RelationshipRiskPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingPutOrCall, _p_FIX__UnderlyingPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceTimeType, _p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LiquidityIndType, _p_FIX__LiquidityIndTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContingencyType, _p_FIX__ContingencyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriorityIndicator, _p_FIX__PriorityIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradePublishIndicator, _p_FIX__TradePublishIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ImpliedMarketIndicator, _p_FIX__ImpliedMarketIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPxIndicator, _p_FIX__AvgPxIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeAllocIndicator, _p_FIX__TradeAllocIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRptStatus, _p_FIX__TrdRptStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UserStatus, _p_FIX__UserStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListOrderStatus, _p_FIX__ListOrderStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestStatus, _p_FIX__TradeRequestStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SessionStatus, _p_FIX__SessionStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecDefStatus, _p_FIX__SecDefStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExerciseStyle, _p_FIX__ExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegExerciseStyle, _p_FIX__LegExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingExerciseStyle, _p_FIX__UnderlyingExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CustOrderCapacity, _p_FIX__CustOrderCapacityTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrigCustOrderCapacity, _p_FIX__OrigCustOrderCapacityTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlInst, _p_FIX__NoSettlInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocType, _p_FIX__AllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEventDates, _p_FIX__NoComplexEventDatesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteEntryStatus, _p_FIX__QuoteEntryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryStatus, _p_FIX__CollInquiryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesStatus, _p_FIX__TradSesStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteAckStatus, _p_FIX__QuoteAckStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AffirmStatus, _p_FIX__AffirmStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosQtyStatus, _p_FIX__PosQtyStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqStatus, _p_FIX__PosReqStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IntField, 0, 0, 0},  {&_swigt__p_FIX__ListSeqNo, _p_FIX__ListSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaxMessageSize, _p_FIX__MaxMessageSizeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyRelationships, _p_FIX__NoPartyRelationshipsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MarketDepth, _p_FIX__MarketDepthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplResponseError, _p_FIX__ApplResponseErrorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollApplType, _p_FIX__CollApplTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__GTBookingInst, _p_FIX__GTBookingInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumTickets, _p_FIX__NumTicketsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegSwapType, _p_FIX__LegSwapTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderDelay, _p_FIX__OrderDelayTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrades, _p_FIX__NoTradesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityXMLLen, _p_FIX__SecurityXMLLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLLen, _p_FIX__DerivativeSecurityXMLLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearFormat, _p_FIX__MaturityMonthYearFormatTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteCancelType, _p_FIX__QuoteCancelTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ModelType, _p_FIX__ModelTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ResponseTransportType, _p_FIX__ResponseTransportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportType, _p_FIX__TradeReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocReportType, _p_FIX__AllocReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplReportType, _p_FIX__ApplReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultiLegRptTypeReq, _p_FIX__MultiLegRptTypeReqTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoHops, _p_FIX__NoHopsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CrossType, _p_FIX__CrossTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRateSources, _p_FIX__NoRateSourcesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__FlowScheduleType, _p_FIX__FlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegFlowScheduleType, _p_FIX__LegFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeFlowScheduleType, _p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingFlowScheduleType, _p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TickRuleType, _p_FIX__TickRuleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedPartyRole, _p_FIX__NestedPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedPartyRole, _p_FIX__RelatedPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyRole, _p_FIX__PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, _p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested3PartyRole, _p_FIX__Nested3PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyRole, _p_FIX__RelatedContextPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPartyRole, _p_FIX__SettlPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested4PartyRole, _p_FIX__Nested4PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RequestedPartyRole, _p_FIX__RequestedPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyRole, _p_FIX__InstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRepPartyRole, _p_FIX__TrdRepPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContextPartyRole, _p_FIX__ContextPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RootPartyRole, _p_FIX__RootPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyRole, _p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested2PartyRole, _p_FIX__Nested2PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TargetPartyRole, _p_FIX__TargetPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, _p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, _p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDescLen, _p_FIX__EncodedLegSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, _p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen, _p_FIX__RelationshipRiskEncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDescLen, _p_FIX__EncodedMktSegmDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDescLen, _p_FIX__EncodedSecurityListDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDescLen, _p_FIX__EncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RiskEncodedSecurityDescLen, _p_FIX__RiskEncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlObligMode, _p_FIX__SettlObligModeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegNumber, _p_FIX__LegNumberTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StatusValue, _p_FIX__StatusValueTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideQty, _p_FIX__SideQtyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideLiquidityInd, _p_FIX__SideLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LastLiquidityInd, _p_FIX__LastLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__FillLiquidityInd, _p_FIX__FillLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCollInquiryQualifier, _p_FIX__NoCollInquiryQualifierTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryQualifier, _p_FIX__CollInquiryQualifierTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StandInstDbType, _p_FIX__StandInstDbTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMarketSegments, _p_FIX__NoMarketSegmentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TargetStrategy, _p_FIX__TargetStrategyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyAltSubIDs, _p_FIX__NoRelatedPartyAltSubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyAltSubIDs, _p_FIX__NoPartyAltSubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartySubIDs, _p_FIX__NoPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrumentPartySubIDs, _p_FIX__NoInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContextPartySubIDs, _p_FIX__NoContextPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedPartySubIDs, _p_FIX__NoRelatedPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartySubIDs, _p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, _p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested3PartySubIDs, _p_FIX__NoNested3PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested4PartySubIDs, _p_FIX__NoNested4PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedPartySubIDs, _p_FIX__NoNestedPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRootPartySubIDs, _p_FIX__NoRootPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedContextPartySubIDs, _p_FIX__NoRelatedContextPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, _p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionMoveType, _p_FIX__DiscretionMoveTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegMoveType, _p_FIX__PegMoveTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPosAmt, _p_FIX__NoPosAmtTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocNoOrdersType, _p_FIX__AllocNoOrdersTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListNoOrds, _p_FIX__ListNoOrdsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSideTrdRegTS, _p_FIX__NoSideTrdRegTSTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoFills, _p_FIX__TotNoFillsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoFills, _p_FIX__NoFillsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedHeadlineLen, _p_FIX__EncodedHeadlineLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedListExecInstLen, _p_FIX__EncodedListExecInstLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SellerDays, _p_FIX__SellerDaysTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, _p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PaymentMethod, _p_FIX__PaymentMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikePriceDeterminationMethod, _p_FIX__StrikePriceDeterminationMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptMethod, _p_FIX__EncryptMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListMethod, _p_FIX__ListMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DistribPaymentMethod, _p_FIX__DistribPaymentMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordMethod, _p_FIX__EncryptedPasswordMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeListMethod, _p_FIX__DerivativeListMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryMethod, _p_FIX__StrikePriceBoundaryMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultilegPriceMethod, _p_FIX__MultilegPriceMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, _p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocMethod, _p_FIX__AllocMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesMethod, _p_FIX__TradSesMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LastMsgSeqNumProcessed, _p_FIX__LastMsgSeqNumProcessedTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlInstReqRejCode, _p_FIX__SettlInstReqRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocRejCode, _p_FIX__AllocRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IndividualAllocRejCode, _p_FIX__IndividualAllocRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRegistDtls, _p_FIX__NoRegistDtlsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoAllocs, _p_FIX__TotNoAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegAllocs, _p_FIX__NoLegAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAllocs, _p_FIX__NoAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMsgTypes, _p_FIX__NoMsgTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDBookType, _p_FIX__MDBookTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDSubBookType, _p_FIX__MDSubBookTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrAttrib, _p_FIX__NoInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedInstrAttrib, _p_FIX__NoNestedInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrAttrib, _p_FIX__NoDerivativeInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyings, _p_FIX__NoUnderlyingsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOfLegUnderlyings, _p_FIX__NoOfLegUnderlyingsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCompIDs, _p_FIX__NoCompIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrikeRules, _p_FIX__NoStrikeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTimeInForceRules, _p_FIX__NoTimeInForceRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLotTypeRules, _p_FIX__NoLotTypeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOrdTypeRules, _p_FIX__NoOrdTypeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExpiration, _p_FIX__NoExpirationTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentParties, _p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentParties, _p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrumentParties, _p_FIX__NoInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedNewPasswordLen, _p_FIX__EncryptedNewPasswordLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordLen, _p_FIX__EncryptedPasswordLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContextPartyIDs, _p_FIX__NoContextPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedPartyIDs, _p_FIX__NoNestedPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested2PartyIDs, _p_FIX__NoNested2PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyIDs, _p_FIX__NoRelatedPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTargetPartyIDs, _p_FIX__NoTargetPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRootPartyIDs, _p_FIX__NoRootPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyIDs, _p_FIX__NoPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested3PartyIDs, _p_FIX__NoNested3PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedContextPartyIDs, _p_FIX__NoRelatedContextPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrategyParameters, _p_FIX__NoStrategyParametersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegs, _p_FIX__NoLegsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyList, _p_FIX__NoPartyListTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoPartyList, _p_FIX__TotNoPartyListTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegRoundDirection, _p_FIX__PegRoundDirectionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionRoundDirection, _p_FIX__DiscretionRoundDirectionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideTrdSubTyp, _p_FIX__SideTrdSubTypTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoBidComponents, _p_FIX__NoBidComponentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlOblig, _p_FIX__NoSettlObligTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegOffsetType, _p_FIX__PegOffsetTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetType, _p_FIX__DiscretionOffsetTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CustomerOrFirm, _p_FIX__CustomerOrFirmTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesMode, _p_FIX__TradSesModeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegScope, _p_FIX__PegScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityReportID, _p_FIX__SecurityReportIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDReportID, _p_FIX__MDReportIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocLinkType, _p_FIX__AllocLinkTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingAmounts, _p_FIX__NoUnderlyingAmountsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoClearingInstructions, _p_FIX__NoClearingInstructionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDQuoteType, _p_FIX__MDQuoteTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDUpdateType, _p_FIX__MDUpdateTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteType, _p_FIX__QuoteTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnAckType, _p_FIX__StreamAsgnAckTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRespType, _p_FIX__QuoteRespTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnRespType, _p_FIX__CollAsgnRespTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMaturityRules, _p_FIX__NoMaturityRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideLastQty, _p_FIX__SideLastQtyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumReports, _p_FIX__TotNumReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumAssignmentReports, _p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumPosReports, _p_FIX__TotalNumPosReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumTradeReports, _p_FIX__TotNumTradeReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__XmlDataLen, _p_FIX__XmlDataLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecureDataLen, _p_FIX__SecureDataLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CoveredOrUncovered, _p_FIX__CoveredOrUncoveredTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegCoveredOrUncovered, _p_FIX__LegCoveredOrUncoveredTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRequestedPartyRoles, _p_FIX__NoRequestedPartyRolesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTradingSessionRules, _p_FIX__NoTradingSessionRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesEvent, _p_FIX__TradSesEventTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RepoCollateralSecurityType, _p_FIX__RepoCollateralSecurityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegRepoCollateralSecurityType, _p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpirationQtyType, _p_FIX__ExpirationQtyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QtyType, _p_FIX__QtyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuantityType, _p_FIX__QuantityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyListResponseTypes, _p_FIX__NoPartyListResponseTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlDetails, _p_FIX__NoSettlDetailsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CPProgram, _p_FIX__CPProgramTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplTotalMessageCount, _p_FIX__ApplTotalMessageCountTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrement, _p_FIX__MaturityMonthYearIncrementTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityResponseType, _p_FIX__SecurityResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplResponseType, _p_FIX__ApplResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueDepth, _p_FIX__ApplQueueDepthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyListResponseType, _p_FIX__PartyListResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetworkStatusResponseType, _p_FIX__NetworkStatusResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEvents, _p_FIX__NoComplexEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventType, _p_FIX__ComplexEventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocAccountType, _p_FIX__AllocAccountTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RespondentType, _p_FIX__RespondentTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AccountType, _p_FIX__AccountTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AdjustmentType, _p_FIX__AdjustmentTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEventType, _p_FIX__DerivativeEventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoEvents, _p_FIX__NoEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeEvents, _p_FIX__NoDerivativeEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EventType, _p_FIX__EventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementType, _p_FIX__UnderlyingSettlementTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAltMDSource, _p_FIX__NoAltMDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AcctIDSource, _p_FIX__AcctIDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderHandlingInstSource, _p_FIX__OrderHandlingInstSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocAcctIDSource, _p_FIX__AllocAcctIDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListTypeSource, _p_FIX__SecurityListTypeSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RateSource, _p_FIX__RateSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeskTypeSource, _p_FIX__DeskTypeSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BidType, _p_FIX__BidTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDates, _p_FIX__NoDatesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrategyParameterType, _p_FIX__StrategyParameterTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OwnerType, _p_FIX__OwnerTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSides, _p_FIX__NoSidesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeNTPositionLimit, _p_FIX__DerivativeNTPositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDOriginType, _p_FIX__MDOriginTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PositionLimit, _p_FIX__PositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NTPositionLimit, _p_FIX__NTPositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CrossPrioritization, _p_FIX__CrossPrioritizationTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativePositionLimit, _p_FIX__DerivativePositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoRejQuotes, _p_FIX__TotNoRejQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoCxldQuotes, _p_FIX__TotNoCxldQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocHandlInst, _p_FIX__AllocHandlInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDFeedTypes, _p_FIX__NoMDFeedTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoAccQuotes, _p_FIX__TotNoAccQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoBidDescriptors, _p_FIX__NoBidDescriptorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrdRepIndicators, _p_FIX__NoTrdRepIndicatorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStatsIndicators, _p_FIX__NoStatsIndicatorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegStipulations, _p_FIX__NoLegStipulationsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStipulations, _p_FIX__NoStipulationsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDistribInsts, _p_FIX__NoDistribInstsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumSecurities, _p_FIX__TotalNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LiquidityNumSecurities, _p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderDelayUnit, _p_FIX__OrderDelayUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EndSeqNo, _p_FIX__EndSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRpts, _p_FIX__NoRptsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityTradingEvent, _p_FIX__SecurityTradingEventTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdSubType, _p_FIX__TrdSubTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ProgRptReqs, _p_FIX__ProgRptReqsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumSecurityTypes, _p_FIX__TotalNumSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDEntryTypes, _p_FIX__NoMDEntryTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ProgPeriodInterval, _p_FIX__ProgPeriodIntervalTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoSecurityTypes, _p_FIX__TotNoSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSecurityTypes, _p_FIX__NoSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContAmtType, _p_FIX__ContAmtTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnTransType, _p_FIX__CollAsgnTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportTransType, _p_FIX__TradeReportTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionResponse, _p_FIX__MassActionResponseTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmTransType, _p_FIX__ConfirmTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosTransType, _p_FIX__PosTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BidDescriptorType, _p_FIX__BidDescriptorTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TaxAdvantageType, _p_FIX__TaxAdvantageTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested2PartySubIDType, _p_FIX__Nested2PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, _p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, _p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedPartySubIDType, _p_FIX__RelatedPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyAltSubIDType, _p_FIX__PartyAltSubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedPartySubIDType, _p_FIX__NestedPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested3PartySubIDType, _p_FIX__Nested3PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltSubIDType, _p_FIX__RelatedPartyAltSubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPartySubIDType, _p_FIX__SettlPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested4PartySubIDType, _p_FIX__Nested4PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRiskLimits, _p_FIX__NoRiskLimitsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelationshipRiskLimits, _p_FIX__NoRelationshipRiskLimitsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, _p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RootPartySubIDType, _p_FIX__RootPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubIDType, _p_FIX__InstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartySubIDType, _p_FIX__PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContextPartySubIDType, _p_FIX__ContextPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubIDType, _p_FIX__RelatedContextPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedTextLen, _p_FIX__EncodedTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedAllocTextLen, _p_FIX__EncodedAllocTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedListStatusTextLen, _p_FIX__EncodedListStatusTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteQualifiers, _p_FIX__NoQuoteQualifiersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoIOIQualifiers, _p_FIX__NoIOIQualifiersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDEntryPositionNo, _p_FIX__MDEntryPositionNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BeginSeqNo, _p_FIX__BeginSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassStatusReqType, _p_FIX__MassStatusReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqType, _p_FIX__PosReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocIntermedReqType, _p_FIX__AllocIntermedReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqType, _p_FIX__StreamAsgnReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplReqType, _p_FIX__ApplReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSubjectLen, _p_FIX__EncodedSubjectLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeliveryType, _p_FIX__DeliveryTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlDeliveryType, _p_FIX__SettlDeliveryTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewsCategory, _p_FIX__NewsCategoryTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyRelationship, _p_FIX__PartyRelationshipTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdType, _p_FIX__TrdTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecondaryTrdType, _p_FIX__SecondaryTrdTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoRelatedSym, _p_FIX__TotNoRelatedSymTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedSym, _p_FIX__NoRelatedSymTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpirationCycle, _p_FIX__ExpirationCycleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueMax, _p_FIX__ApplQueueMaxTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedPartyAltIDs, _p_FIX__NoRelatedPartyAltIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyAltIDs, _p_FIX__NoPartyAltIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAction, _p_FIX__CollActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintAction, _p_FIX__PosMaintActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewsRefType, _p_FIX__NewsRefTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueAction, _p_FIX__ApplQueueActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LinesOfText, _p_FIX__LinesOfTextTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionScope, _p_FIX__MassActionScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLinesOfText, _p_FIX__NoLinesOfTextTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionScope, _p_FIX__DiscretionScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribType, _p_FIX__DerivativeInstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribType, _p_FIX__NestedInstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrAttribType, _p_FIX__InstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetGrossInd, _p_FIX__NetGrossIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTickRules, _p_FIX__NoTickRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOfSecSizes, _p_FIX__NoOfSecSizesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnType, _p_FIX__StreamAsgnTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrikes, _p_FIX__NoStrikesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoStrikes, _p_FIX__TotNoStrikesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefTagID, _p_FIX__RefTagIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExecs, _p_FIX__NoExecsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideMultiLegReportingType, _p_FIX__SideMultiLegReportingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RoutingType, _p_FIX__RoutingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BookingType, _p_FIX__BookingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumDaysInterest, _p_FIX__NumDaysInterestTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyDetailsRequestResult, _p_FIX__PartyDetailsRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityRequestResult, _p_FIX__SecurityRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintResult, _p_FIX__PosMaintResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RawDataLength, _p_FIX__RawDataLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BodyLength, _p_FIX__BodyLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SignatureLength, _p_FIX__SignatureLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSymbolLen, _p_FIX__EncodedSymbolLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplExtID, _p_FIX__ApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DefaultApplExtID, _p_FIX__DefaultApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefApplExtID, _p_FIX__RefApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRoutingIDs, _p_FIX__NoRoutingIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewSeqNo, _p_FIX__NewSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, _p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HaltReasonInt, _p_FIX__HaltReasonIntTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingStips, _p_FIX__NoUnderlyingStipsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmType, _p_FIX__ConfirmTypeTo_p_FIX__IntField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InterestAccrualDate[] = {  {&_swigt__p_FIX__InterestAccrualDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InterestAtMaturity[] = {  {&_swigt__p_FIX__InterestAtMaturity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidMessage[] = {  {&_swigt__p_FIX__InvalidMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidMessageType[] = {  {&_swigt__p_FIX__InvalidMessageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidTagNumber[] = {  {&_swigt__p_FIX__InvalidTagNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvestorCountryOfResidence[] = {  {&_swigt__p_FIX__InvestorCountryOfResidence, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IssueDate[] = {  {&_swigt__p_FIX__IssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Issuer[] = {  {&_swigt__p_FIX__Issuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LANGUAGE[] = {  {&_swigt__p_FIX__LANGUAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LENGTH[] = {  {&_swigt__p_FIX__LENGTH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LOCALMKTDATE[] = {  {&_swigt__p_FIX__LOCALMKTDATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LanguageCode[] = {  {&_swigt__p_FIX__LanguageCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastCapacity[] = {  {&_swigt__p_FIX__LastCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastForwardPoints[] = {  {&_swigt__p_FIX__LastForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastForwardPoints2[] = {  {&_swigt__p_FIX__LastForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastFragment[] = {  {&_swigt__p_FIX__LastFragment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastLiquidityInd[] = {  {&_swigt__p_FIX__LastLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastMkt[] = {  {&_swigt__p_FIX__LastMkt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastMsgSeqNumProcessed[] = {  {&_swigt__p_FIX__LastMsgSeqNumProcessed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastNetworkResponseID[] = {  {&_swigt__p_FIX__LastNetworkResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastParPx[] = {  {&_swigt__p_FIX__LastParPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastPx[] = {  {&_swigt__p_FIX__LastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastQty[] = {  {&_swigt__p_FIX__LastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastRptRequested[] = {  {&_swigt__p_FIX__LastRptRequested, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastShares[] = {  {&_swigt__p_FIX__LastShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastSpotRate[] = {  {&_swigt__p_FIX__LastSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastSwapPoints[] = {  {&_swigt__p_FIX__LastSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastUpdateTime[] = {  {&_swigt__p_FIX__LastUpdateTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LateIndicator[] = {  {&_swigt__p_FIX__LateIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LeavesQty[] = {  {&_swigt__p_FIX__LeavesQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocAccount[] = {  {&_swigt__p_FIX__LegAllocAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocAcctIDSource[] = {  {&_swigt__p_FIX__LegAllocAcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocID[] = {  {&_swigt__p_FIX__LegAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocQty[] = {  {&_swigt__p_FIX__LegAllocQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocSettlCurrency[] = {  {&_swigt__p_FIX__LegAllocSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurveCurrency[] = {  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurveName[] = {  {&_swigt__p_FIX__LegBenchmarkCurveName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurvePoint[] = {  {&_swigt__p_FIX__LegBenchmarkCurvePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkPrice[] = {  {&_swigt__p_FIX__LegBenchmarkPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkPriceType[] = {  {&_swigt__p_FIX__LegBenchmarkPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBidForwardPoints[] = {  {&_swigt__p_FIX__LegBidForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBidPx[] = {  {&_swigt__p_FIX__LegBidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCFICode[] = {  {&_swigt__p_FIX__LegCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCalculatedCcyLastQty[] = {  {&_swigt__p_FIX__LegCalculatedCcyLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractMultiplier[] = {  {&_swigt__p_FIX__LegContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractMultiplierUnit[] = {  {&_swigt__p_FIX__LegContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractSettlMonth[] = {  {&_swigt__p_FIX__LegContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCountryOfIssue[] = {  {&_swigt__p_FIX__LegCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCouponPaymentDate[] = {  {&_swigt__p_FIX__LegCouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCouponRate[] = {  {&_swigt__p_FIX__LegCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCoveredOrUncovered[] = {  {&_swigt__p_FIX__LegCoveredOrUncovered, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCreditRating[] = {  {&_swigt__p_FIX__LegCreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCurrency[] = {  {&_swigt__p_FIX__LegCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCurrencyRatio[] = {  {&_swigt__p_FIX__LegCurrencyRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegDatedDate[] = {  {&_swigt__p_FIX__LegDatedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegDividendYield[] = {  {&_swigt__p_FIX__LegDividendYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegExecInst[] = {  {&_swigt__p_FIX__LegExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegExerciseStyle[] = {  {&_swigt__p_FIX__LegExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFactor[] = {  {&_swigt__p_FIX__LegFactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFlowScheduleType[] = {  {&_swigt__p_FIX__LegFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFutSettDate[] = {  {&_swigt__p_FIX__LegFutSettDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegGrossTradeAmt[] = {  {&_swigt__p_FIX__LegGrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIOIQty[] = {  {&_swigt__p_FIX__LegIOIQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIndividualAllocID[] = {  {&_swigt__p_FIX__LegIndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegInstrRegistry[] = {  {&_swigt__p_FIX__LegInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegInterestAccrualDate[] = {  {&_swigt__p_FIX__LegInterestAccrualDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIssueDate[] = {  {&_swigt__p_FIX__LegIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIssuer[] = {  {&_swigt__p_FIX__LegIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastForwardPoints[] = {  {&_swigt__p_FIX__LegLastForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastPx[] = {  {&_swigt__p_FIX__LegLastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastQty[] = {  {&_swigt__p_FIX__LegLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLocaleOfIssue[] = {  {&_swigt__p_FIX__LegLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityDate[] = {  {&_swigt__p_FIX__LegMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityMonthYear[] = {  {&_swigt__p_FIX__LegMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityTime[] = {  {&_swigt__p_FIX__LegMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegNumber[] = {  {&_swigt__p_FIX__LegNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOfferForwardPoints[] = {  {&_swigt__p_FIX__LegOfferForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOfferPx[] = {  {&_swigt__p_FIX__LegOfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOptAttribute[] = {  {&_swigt__p_FIX__LegOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOptionRatio[] = {  {&_swigt__p_FIX__LegOptionRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOrderQty[] = {  {&_swigt__p_FIX__LegOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPool[] = {  {&_swigt__p_FIX__LegPool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPositionEffect[] = {  {&_swigt__p_FIX__LegPositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPrice[] = {  {&_swigt__p_FIX__LegPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceType[] = {  {&_swigt__p_FIX__LegPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceUnitOfMeasure[] = {  {&_swigt__p_FIX__LegPriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegProduct[] = {  {&_swigt__p_FIX__LegProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPutOrCall[] = {  {&_swigt__p_FIX__LegPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegQty[] = {  {&_swigt__p_FIX__LegQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRatioQty[] = {  {&_swigt__p_FIX__LegRatioQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRedemptionDate[] = {  {&_swigt__p_FIX__LegRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRefID[] = {  {&_swigt__p_FIX__LegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepoCollateralSecurityType[] = {  {&_swigt__p_FIX__LegRepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegReportID[] = {  {&_swigt__p_FIX__LegReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepurchaseRate[] = {  {&_swigt__p_FIX__LegRepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepurchaseTerm[] = {  {&_swigt__p_FIX__LegRepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityAltID[] = {  {&_swigt__p_FIX__LegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityAltIDSource[] = {  {&_swigt__p_FIX__LegSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityDesc[] = {  {&_swigt__p_FIX__LegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityExchange[] = {  {&_swigt__p_FIX__LegSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityID[] = {  {&_swigt__p_FIX__LegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityIDSource[] = {  {&_swigt__p_FIX__LegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecuritySubType[] = {  {&_swigt__p_FIX__LegSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityType[] = {  {&_swigt__p_FIX__LegSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlCurrency[] = {  {&_swigt__p_FIX__LegSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlDate[] = {  {&_swigt__p_FIX__LegSettlDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlType[] = {  {&_swigt__p_FIX__LegSettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlmntTyp[] = {  {&_swigt__p_FIX__LegSettlmntTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSide[] = {  {&_swigt__p_FIX__LegSide, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStipulationType[] = {  {&_swigt__p_FIX__LegStipulationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStipulationValue[] = {  {&_swigt__p_FIX__LegStipulationValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStrikeCurrency[] = {  {&_swigt__p_FIX__LegStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStrikePrice[] = {  {&_swigt__p_FIX__LegStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSwapType[] = {  {&_swigt__p_FIX__LegSwapType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSymbol[] = {  {&_swigt__p_FIX__LegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSymbolSfx[] = {  {&_swigt__p_FIX__LegSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegTimeUnit[] = {  {&_swigt__p_FIX__LegTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegUnitOfMeasure[] = {  {&_swigt__p_FIX__LegUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegUnitOfMeasureQty[] = {  {&_swigt__p_FIX__LegUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegVolatility[] = {  {&_swigt__p_FIX__LegVolatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegalConfirm[] = {  {&_swigt__p_FIX__LegalConfirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LinesOfText[] = {  {&_swigt__p_FIX__LinesOfText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityIndType[] = {  {&_swigt__p_FIX__LiquidityIndType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityNumSecurities[] = {  {&_swigt__p_FIX__LiquidityNumSecurities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityPctHigh[] = {  {&_swigt__p_FIX__LiquidityPctHigh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityPctLow[] = {  {&_swigt__p_FIX__LiquidityPctLow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityValue[] = {  {&_swigt__p_FIX__LiquidityValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListExecInst[] = {  {&_swigt__p_FIX__ListExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListExecInstType[] = {  {&_swigt__p_FIX__ListExecInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListID[] = {  {&_swigt__p_FIX__ListID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListMethod[] = {  {&_swigt__p_FIX__ListMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListName[] = {  {&_swigt__p_FIX__ListName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListNoOrds[] = {  {&_swigt__p_FIX__ListNoOrds, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListOrderStatus[] = {  {&_swigt__p_FIX__ListOrderStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListRejectReason[] = {  {&_swigt__p_FIX__ListRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListSeqNo[] = {  {&_swigt__p_FIX__ListSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListStatusText[] = {  {&_swigt__p_FIX__ListStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListStatusType[] = {  {&_swigt__p_FIX__ListStatusType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListUpdateAction[] = {  {&_swigt__p_FIX__ListUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocaleOfIssue[] = {  {&_swigt__p_FIX__LocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocateReqd[] = {  {&_swigt__p_FIX__LocateReqd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocationID[] = {  {&_swigt__p_FIX__LocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Log[] = {  {&_swigt__p_FIX__NullLog, _p_FIX__NullLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__Log, 0, 0, 0},  {&_swigt__p_FIX__FileLog, _p_FIX__FileLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__ScreenLog, _p_FIX__ScreenLogTo_p_FIX__Log, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LogFactory[] = {  {&_swigt__p_FIX__LogFactory, 0, 0, 0},  {&_swigt__p_FIX__ScreenLogFactory, _p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory, 0, 0},  {&_swigt__p_FIX__FileLogFactory, _p_FIX__FileLogFactoryTo_p_FIX__LogFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LongQty[] = {  {&_swigt__p_FIX__LongQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LotType[] = {  {&_swigt__p_FIX__LotType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LowLimitPrice[] = {  {&_swigt__p_FIX__LowLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LowPx[] = {  {&_swigt__p_FIX__LowPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDBookType[] = {  {&_swigt__p_FIX__MDBookType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryBuyer[] = {  {&_swigt__p_FIX__MDEntryBuyer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryDate[] = {  {&_swigt__p_FIX__MDEntryDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryForwardPoints[] = {  {&_swigt__p_FIX__MDEntryForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryID[] = {  {&_swigt__p_FIX__MDEntryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryOriginator[] = {  {&_swigt__p_FIX__MDEntryOriginator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryPositionNo[] = {  {&_swigt__p_FIX__MDEntryPositionNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryPx[] = {  {&_swigt__p_FIX__MDEntryPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryRefID[] = {  {&_swigt__p_FIX__MDEntryRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySeller[] = {  {&_swigt__p_FIX__MDEntrySeller, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySize[] = {  {&_swigt__p_FIX__MDEntrySize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySpotRate[] = {  {&_swigt__p_FIX__MDEntrySpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryTime[] = {  {&_swigt__p_FIX__MDEntryTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryType[] = {  {&_swigt__p_FIX__MDEntryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDFeedType[] = {  {&_swigt__p_FIX__MDFeedType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDImplicitDelete[] = {  {&_swigt__p_FIX__MDImplicitDelete, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDMkt[] = {  {&_swigt__p_FIX__MDMkt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDOriginType[] = {  {&_swigt__p_FIX__MDOriginType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDPriceLevel[] = {  {&_swigt__p_FIX__MDPriceLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDQuoteType[] = {  {&_swigt__p_FIX__MDQuoteType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReportID[] = {  {&_swigt__p_FIX__MDReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReqID[] = {  {&_swigt__p_FIX__MDReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReqRejReason[] = {  {&_swigt__p_FIX__MDReqRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSecSize[] = {  {&_swigt__p_FIX__MDSecSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSecSizeType[] = {  {&_swigt__p_FIX__MDSecSizeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDStreamID[] = {  {&_swigt__p_FIX__MDStreamID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSubBookType[] = {  {&_swigt__p_FIX__MDSubBookType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDUpdateAction[] = {  {&_swigt__p_FIX__MDUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDUpdateType[] = {  {&_swigt__p_FIX__MDUpdateType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MONTHYEAR[] = {  {&_swigt__p_FIX__MONTHYEAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLECHARVALUE[] = {  {&_swigt__p_FIX__MULTIPLECHARVALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLESTRINGVALUE[] = {  {&_swigt__p_FIX__MULTIPLESTRINGVALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLEVALUESTRING[] = {  {&_swigt__p_FIX__MULTIPLEVALUESTRING, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MailingDtls[] = {  {&_swigt__p_FIX__MailingDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MailingInst[] = {  {&_swigt__p_FIX__MailingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ManualOrderIndicator[] = {  {&_swigt__p_FIX__ManualOrderIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarginExcess[] = {  {&_swigt__p_FIX__MarginExcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarginRatio[] = {  {&_swigt__p_FIX__MarginRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketDepth[] = {  {&_swigt__p_FIX__MarketDepth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketID[] = {  {&_swigt__p_FIX__MarketID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketReportID[] = {  {&_swigt__p_FIX__MarketReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketReqID[] = {  {&_swigt__p_FIX__MarketReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketSegmentDesc[] = {  {&_swigt__p_FIX__MarketSegmentDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketSegmentID[] = {  {&_swigt__p_FIX__MarketSegmentID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketUpdateAction[] = {  {&_swigt__p_FIX__MarketUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionRejectReason[] = {  {&_swigt__p_FIX__MassActionRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionReportID[] = {  {&_swigt__p_FIX__MassActionReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionResponse[] = {  {&_swigt__p_FIX__MassActionResponse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionScope[] = {  {&_swigt__p_FIX__MassActionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionType[] = {  {&_swigt__p_FIX__MassActionType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelRejectReason[] = {  {&_swigt__p_FIX__MassCancelRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelRequestType[] = {  {&_swigt__p_FIX__MassCancelRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelResponse[] = {  {&_swigt__p_FIX__MassCancelResponse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassStatusReqID[] = {  {&_swigt__p_FIX__MassStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassStatusReqType[] = {  {&_swigt__p_FIX__MassStatusReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchAlgorithm[] = {  {&_swigt__p_FIX__MatchAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchIncrement[] = {  {&_swigt__p_FIX__MatchIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchStatus[] = {  {&_swigt__p_FIX__MatchStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchType[] = {  {&_swigt__p_FIX__MatchType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityDate[] = {  {&_swigt__p_FIX__MaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityDay[] = {  {&_swigt__p_FIX__MaturityDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYear[] = {  {&_swigt__p_FIX__MaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearFormat[] = {  {&_swigt__p_FIX__MaturityMonthYearFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearIncrement[] = {  {&_swigt__p_FIX__MaturityMonthYearIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearIncrementUnits[] = {  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityNetMoney[] = {  {&_swigt__p_FIX__MaturityNetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityRuleID[] = {  {&_swigt__p_FIX__MaturityRuleID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityTime[] = {  {&_swigt__p_FIX__MaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxFloor[] = {  {&_swigt__p_FIX__MaxFloor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxMessageSize[] = {  {&_swigt__p_FIX__MaxMessageSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxPriceLevels[] = {  {&_swigt__p_FIX__MaxPriceLevels, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxPriceVariation[] = {  {&_swigt__p_FIX__MaxPriceVariation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxShow[] = {  {&_swigt__p_FIX__MaxShow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxTradeVol[] = {  {&_swigt__p_FIX__MaxTradeVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MemoryStore[] = {  {&_swigt__p_FIX__MemoryStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MemoryStoreFactory[] = {  {&_swigt__p_FIX__MemoryStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Message[] = {  {&_swigt__p_FIX__Message, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageEncoding[] = {  {&_swigt__p_FIX__MessageEncoding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageEventSource[] = {  {&_swigt__p_FIX__MessageEventSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageParseError[] = {  {&_swigt__p_FIX__MessageParseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStore[] = {  {&_swigt__p_FIX__MemoryStore, _p_FIX__MemoryStoreTo_p_FIX__MessageStore, 0, 0},  {&_swigt__p_FIX__MessageStore, 0, 0, 0},  {&_swigt__p_FIX__FileStore, _p_FIX__FileStoreTo_p_FIX__MessageStore, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreExceptionWrapper[] = {  {&_swigt__p_FIX__MessageStoreExceptionWrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreFactory[] = {  {&_swigt__p_FIX__MessageStoreFactory, 0, 0, 0},  {&_swigt__p_FIX__MemoryStoreFactory, _p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},  {&_swigt__p_FIX__FileStoreFactory, _p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreFactoryExceptionWrapper[] = {  {&_swigt__p_FIX__MessageStoreFactoryExceptionWrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MidPx[] = {  {&_swigt__p_FIX__MidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MidYield[] = {  {&_swigt__p_FIX__MidYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinBidSize[] = {  {&_swigt__p_FIX__MinBidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinLotSize[] = {  {&_swigt__p_FIX__MinLotSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinOfferSize[] = {  {&_swigt__p_FIX__MinOfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinPriceIncrement[] = {  {&_swigt__p_FIX__MinPriceIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinPriceIncrementAmount[] = {  {&_swigt__p_FIX__MinPriceIncrementAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinQty[] = {  {&_swigt__p_FIX__MinQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinTradeVol[] = {  {&_swigt__p_FIX__MinTradeVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeAmt[] = {  {&_swigt__p_FIX__MiscFeeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeBasis[] = {  {&_swigt__p_FIX__MiscFeeBasis, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeCurr[] = {  {&_swigt__p_FIX__MiscFeeCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeType[] = {  {&_swigt__p_FIX__MiscFeeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MktBidPx[] = {  {&_swigt__p_FIX__MktBidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MktOfferPx[] = {  {&_swigt__p_FIX__MktOfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ModelType[] = {  {&_swigt__p_FIX__ModelType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MoneyLaunderingStatus[] = {  {&_swigt__p_FIX__MoneyLaunderingStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgDirection[] = {  {&_swigt__p_FIX__MsgDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgSeqNum[] = {  {&_swigt__p_FIX__MsgSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgType[] = {  {&_swigt__p_FIX__MsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultiLegReportingType[] = {  {&_swigt__p_FIX__MultiLegReportingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultiLegRptTypeReq[] = {  {&_swigt__p_FIX__MultiLegRptTypeReq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultilegModel[] = {  {&_swigt__p_FIX__MultilegModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultilegPriceMethod[] = {  {&_swigt__p_FIX__MultilegPriceMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NTPositionLimit[] = {  {&_swigt__p_FIX__NTPositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NUMINGROUP[] = {  {&_swigt__p_FIX__NUMINGROUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyID[] = {  {&_swigt__p_FIX__Nested2PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyIDSource[] = {  {&_swigt__p_FIX__Nested2PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyRole[] = {  {&_swigt__p_FIX__Nested2PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartySubID[] = {  {&_swigt__p_FIX__Nested2PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartySubIDType[] = {  {&_swigt__p_FIX__Nested2PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyID[] = {  {&_swigt__p_FIX__Nested3PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyIDSource[] = {  {&_swigt__p_FIX__Nested3PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyRole[] = {  {&_swigt__p_FIX__Nested3PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartySubID[] = {  {&_swigt__p_FIX__Nested3PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartySubIDType[] = {  {&_swigt__p_FIX__Nested3PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyID[] = {  {&_swigt__p_FIX__Nested4PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyIDSource[] = {  {&_swigt__p_FIX__Nested4PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyRole[] = {  {&_swigt__p_FIX__Nested4PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartySubID[] = {  {&_swigt__p_FIX__Nested4PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartySubIDType[] = {  {&_swigt__p_FIX__Nested4PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedInstrAttribType[] = {  {&_swigt__p_FIX__NestedInstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedInstrAttribValue[] = {  {&_swigt__p_FIX__NestedInstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyID[] = {  {&_swigt__p_FIX__NestedPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyIDSource[] = {  {&_swigt__p_FIX__NestedPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyRole[] = {  {&_swigt__p_FIX__NestedPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartySubID[] = {  {&_swigt__p_FIX__NestedPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartySubIDType[] = {  {&_swigt__p_FIX__NestedPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetChgPrevDay[] = {  {&_swigt__p_FIX__NetChgPrevDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetGrossInd[] = {  {&_swigt__p_FIX__NetGrossInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetMoney[] = {  {&_swigt__p_FIX__NetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkRequestID[] = {  {&_swigt__p_FIX__NetworkRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkRequestType[] = {  {&_swigt__p_FIX__NetworkRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkResponseID[] = {  {&_swigt__p_FIX__NetworkResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkStatusResponseType[] = {  {&_swigt__p_FIX__NetworkStatusResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewPassword[] = {  {&_swigt__p_FIX__NewPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewSeqNo[] = {  {&_swigt__p_FIX__NewSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsCategory[] = {  {&_swigt__p_FIX__NewsCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsID[] = {  {&_swigt__p_FIX__NewsID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsRefID[] = {  {&_swigt__p_FIX__NewsRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsRefType[] = {  {&_swigt__p_FIX__NewsRefType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NextExpectedMsgSeqNum[] = {  {&_swigt__p_FIX__NextExpectedMsgSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAffectedOrders[] = {  {&_swigt__p_FIX__NoAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAllocs[] = {  {&_swigt__p_FIX__NoAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAltMDSource[] = {  {&_swigt__p_FIX__NoAltMDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoApplIDs[] = {  {&_swigt__p_FIX__NoApplIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAsgnReqs[] = {  {&_swigt__p_FIX__NoAsgnReqs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoBidComponents[] = {  {&_swigt__p_FIX__NoBidComponents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoBidDescriptors[] = {  {&_swigt__p_FIX__NoBidDescriptors, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCapacities[] = {  {&_swigt__p_FIX__NoCapacities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoClearingInstructions[] = {  {&_swigt__p_FIX__NoClearingInstructions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCollInquiryQualifier[] = {  {&_swigt__p_FIX__NoCollInquiryQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCompIDs[] = {  {&_swigt__p_FIX__NoCompIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEventDates[] = {  {&_swigt__p_FIX__NoComplexEventDates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEventTimes[] = {  {&_swigt__p_FIX__NoComplexEventTimes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEvents[] = {  {&_swigt__p_FIX__NoComplexEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContAmts[] = {  {&_swigt__p_FIX__NoContAmts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContextPartyIDs[] = {  {&_swigt__p_FIX__NoContextPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContextPartySubIDs[] = {  {&_swigt__p_FIX__NoContextPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContraBrokers[] = {  {&_swigt__p_FIX__NoContraBrokers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDates[] = {  {&_swigt__p_FIX__NoDates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeEvents[] = {  {&_swigt__p_FIX__NoDerivativeEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrAttrib[] = {  {&_swigt__p_FIX__NoDerivativeInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrumentParties[] = {  {&_swigt__p_FIX__NoDerivativeInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeSecurityAltID[] = {  {&_swigt__p_FIX__NoDerivativeSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDistribInsts[] = {  {&_swigt__p_FIX__NoDistribInsts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDlvyInst[] = {  {&_swigt__p_FIX__NoDlvyInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoEvents[] = {  {&_swigt__p_FIX__NoEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExecInstRules[] = {  {&_swigt__p_FIX__NoExecInstRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExecs[] = {  {&_swigt__p_FIX__NoExecs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExpiration[] = {  {&_swigt__p_FIX__NoExpiration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoFills[] = {  {&_swigt__p_FIX__NoFills, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoHops[] = {  {&_swigt__p_FIX__NoHops, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoIOIQualifiers[] = {  {&_swigt__p_FIX__NoIOIQualifiers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrAttrib[] = {  {&_swigt__p_FIX__NoInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrumentParties[] = {  {&_swigt__p_FIX__NoInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegAllocs[] = {  {&_swigt__p_FIX__NoLegAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegSecurityAltID[] = {  {&_swigt__p_FIX__NoLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegStipulations[] = {  {&_swigt__p_FIX__NoLegStipulations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegs[] = {  {&_swigt__p_FIX__NoLegs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLinesOfText[] = {  {&_swigt__p_FIX__NoLinesOfText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLotTypeRules[] = {  {&_swigt__p_FIX__NoLotTypeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDEntries[] = {  {&_swigt__p_FIX__NoMDEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDEntryTypes[] = {  {&_swigt__p_FIX__NoMDEntryTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDFeedTypes[] = {  {&_swigt__p_FIX__NoMDFeedTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMarketSegments[] = {  {&_swigt__p_FIX__NoMarketSegments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMatchRules[] = {  {&_swigt__p_FIX__NoMatchRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMaturityRules[] = {  {&_swigt__p_FIX__NoMaturityRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMiscFees[] = {  {&_swigt__p_FIX__NoMiscFees, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMsgTypes[] = {  {&_swigt__p_FIX__NoMsgTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested2PartyIDs[] = {  {&_swigt__p_FIX__NoNested2PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested2PartySubIDs[] = {  {&_swigt__p_FIX__NoNested2PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested3PartyIDs[] = {  {&_swigt__p_FIX__NoNested3PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested3PartySubIDs[] = {  {&_swigt__p_FIX__NoNested3PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested4PartyIDs[] = {  {&_swigt__p_FIX__NoNested4PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested4PartySubIDs[] = {  {&_swigt__p_FIX__NoNested4PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedInstrAttrib[] = {  {&_swigt__p_FIX__NoNestedInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedPartyIDs[] = {  {&_swigt__p_FIX__NoNestedPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedPartySubIDs[] = {  {&_swigt__p_FIX__NoNestedPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNewsRefIDs[] = {  {&_swigt__p_FIX__NoNewsRefIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNotAffectedOrders[] = {  {&_swigt__p_FIX__NoNotAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOfLegUnderlyings[] = {  {&_swigt__p_FIX__NoOfLegUnderlyings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOfSecSizes[] = {  {&_swigt__p_FIX__NoOfSecSizes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOrdTypeRules[] = {  {&_swigt__p_FIX__NoOrdTypeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOrders[] = {  {&_swigt__p_FIX__NoOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyAltIDs[] = {  {&_swigt__p_FIX__NoPartyAltIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyAltSubIDs[] = {  {&_swigt__p_FIX__NoPartyAltSubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyIDs[] = {  {&_swigt__p_FIX__NoPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyList[] = {  {&_swigt__p_FIX__NoPartyList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyListResponseTypes[] = {  {&_swigt__p_FIX__NoPartyListResponseTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyRelationships[] = {  {&_swigt__p_FIX__NoPartyRelationships, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartySubIDs[] = {  {&_swigt__p_FIX__NoPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPosAmt[] = {  {&_swigt__p_FIX__NoPosAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPositions[] = {  {&_swigt__p_FIX__NoPositions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteEntries[] = {  {&_swigt__p_FIX__NoQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteQualifiers[] = {  {&_swigt__p_FIX__NoQuoteQualifiers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteSets[] = {  {&_swigt__p_FIX__NoQuoteSets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRateSources[] = {  {&_swigt__p_FIX__NoRateSources, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRegistDtls[] = {  {&_swigt__p_FIX__NoRegistDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedContextPartyIDs[] = {  {&_swigt__p_FIX__NoRelatedContextPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedContextPartySubIDs[] = {  {&_swigt__p_FIX__NoRelatedContextPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartyAltIDs[] = {  {&_swigt__p_FIX__NoRelatedPartyAltIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartyAltSubIDs[] = {  {&_swigt__p_FIX__NoRelatedPartyAltSubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartyIDs[] = {  {&_swigt__p_FIX__NoRelatedPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedPartySubIDs[] = {  {&_swigt__p_FIX__NoRelatedPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedSym[] = {  {&_swigt__p_FIX__NoRelatedSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelationshipRiskInstruments[] = {  {&_swigt__p_FIX__NoRelationshipRiskInstruments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelationshipRiskLimits[] = {  {&_swigt__p_FIX__NoRelationshipRiskLimits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelationshipRiskSecurityAltID[] = {  {&_swigt__p_FIX__NoRelationshipRiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelationshipRiskWarningLevels[] = {  {&_swigt__p_FIX__NoRelationshipRiskWarningLevels, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRequestedPartyRoles[] = {  {&_swigt__p_FIX__NoRequestedPartyRoles, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskInstruments[] = {  {&_swigt__p_FIX__NoRiskInstruments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskLimits[] = {  {&_swigt__p_FIX__NoRiskLimits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskSecurityAltID[] = {  {&_swigt__p_FIX__NoRiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRiskWarningLevels[] = {  {&_swigt__p_FIX__NoRiskWarningLevels, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRootPartyIDs[] = {  {&_swigt__p_FIX__NoRootPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRootPartySubIDs[] = {  {&_swigt__p_FIX__NoRootPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRoutingIDs[] = {  {&_swigt__p_FIX__NoRoutingIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRpts[] = {  {&_swigt__p_FIX__NoRpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSecurityAltID[] = {  {&_swigt__p_FIX__NoSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSecurityTypes[] = {  {&_swigt__p_FIX__NoSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlDetails[] = {  {&_swigt__p_FIX__NoSettlDetails, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlInst[] = {  {&_swigt__p_FIX__NoSettlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlOblig[] = {  {&_swigt__p_FIX__NoSettlOblig, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlPartyIDs[] = {  {&_swigt__p_FIX__NoSettlPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlPartySubIDs[] = {  {&_swigt__p_FIX__NoSettlPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSideTrdRegTS[] = {  {&_swigt__p_FIX__NoSideTrdRegTS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSides[] = {  {&_swigt__p_FIX__NoSides, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStatsIndicators[] = {  {&_swigt__p_FIX__NoStatsIndicators, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStipulations[] = {  {&_swigt__p_FIX__NoStipulations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrategyParameters[] = {  {&_swigt__p_FIX__NoStrategyParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrikeRules[] = {  {&_swigt__p_FIX__NoStrikeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrikes[] = {  {&_swigt__p_FIX__NoStrikes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTagValue[] = {  {&_swigt__p_FIX__NoTagValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTargetPartyIDs[] = {  {&_swigt__p_FIX__NoTargetPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTickRules[] = {  {&_swigt__p_FIX__NoTickRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTimeInForceRules[] = {  {&_swigt__p_FIX__NoTimeInForceRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrades[] = {  {&_swigt__p_FIX__NoTrades, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTradingSessionRules[] = {  {&_swigt__p_FIX__NoTradingSessionRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTradingSessions[] = {  {&_swigt__p_FIX__NoTradingSessions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrdRegTimestamps[] = {  {&_swigt__p_FIX__NoTrdRegTimestamps, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrdRepIndicators[] = {  {&_swigt__p_FIX__NoTrdRepIndicators, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingAmounts[] = {  {&_swigt__p_FIX__NoUnderlyingAmounts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingLegSecurityAltID[] = {  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingSecurityAltID[] = {  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingStips[] = {  {&_swigt__p_FIX__NoUnderlyingStips, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyings[] = {  {&_swigt__p_FIX__NoUnderlyings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUndlyInstrumentParties[] = {  {&_swigt__p_FIX__NoUndlyInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUndlyInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotAffOrigClOrdID[] = {  {&_swigt__p_FIX__NotAffOrigClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotAffectedOrderID[] = {  {&_swigt__p_FIX__NotAffectedOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotifyBrokerOfCredit[] = {  {&_swigt__p_FIX__NotifyBrokerOfCredit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__NotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NullApplication[] = {  {&_swigt__p_FIX__NullApplication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NullLog[] = {  {&_swigt__p_FIX__NullLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumBidders[] = {  {&_swigt__p_FIX__NumBidders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumDaysInterest[] = {  {&_swigt__p_FIX__NumDaysInterest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumTickets[] = {  {&_swigt__p_FIX__NumTickets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumberOfOrders[] = {  {&_swigt__p_FIX__NumberOfOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OddLot[] = {  {&_swigt__p_FIX__OddLot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferForwardPoints[] = {  {&_swigt__p_FIX__OfferForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferForwardPoints2[] = {  {&_swigt__p_FIX__OfferForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferPx[] = {  {&_swigt__p_FIX__OfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSize[] = {  {&_swigt__p_FIX__OfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSpotRate[] = {  {&_swigt__p_FIX__OfferSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSwapPoints[] = {  {&_swigt__p_FIX__OfferSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferYield[] = {  {&_swigt__p_FIX__OfferYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfCompID[] = {  {&_swigt__p_FIX__OnBehalfOfCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfLocationID[] = {  {&_swigt__p_FIX__OnBehalfOfLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfSendingTime[] = {  {&_swigt__p_FIX__OnBehalfOfSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfSubID[] = {  {&_swigt__p_FIX__OnBehalfOfSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenClose[] = {  {&_swigt__p_FIX__OpenClose, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenCloseSettlFlag[] = {  {&_swigt__p_FIX__OpenCloseSettlFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenCloseSettleFlag[] = {  {&_swigt__p_FIX__OpenCloseSettleFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenInterest[] = {  {&_swigt__p_FIX__OpenInterest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptAttribute[] = {  {&_swigt__p_FIX__OptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayAmount[] = {  {&_swigt__p_FIX__OptPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayoutAmount[] = {  {&_swigt__p_FIX__OptPayoutAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayoutType[] = {  {&_swigt__p_FIX__OptPayoutType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdRejReason[] = {  {&_swigt__p_FIX__OrdRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdStatus[] = {  {&_swigt__p_FIX__OrdStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdStatusReqID[] = {  {&_swigt__p_FIX__OrdStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdType[] = {  {&_swigt__p_FIX__OrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderAvgPx[] = {  {&_swigt__p_FIX__OrderAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderBookingQty[] = {  {&_swigt__p_FIX__OrderBookingQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCapacity[] = {  {&_swigt__p_FIX__OrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCapacityQty[] = {  {&_swigt__p_FIX__OrderCapacityQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCategory[] = {  {&_swigt__p_FIX__OrderCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderDelay[] = {  {&_swigt__p_FIX__OrderDelay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderDelayUnit[] = {  {&_swigt__p_FIX__OrderDelayUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderHandlingInstSource[] = {  {&_swigt__p_FIX__OrderHandlingInstSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderID[] = {  {&_swigt__p_FIX__OrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderInputDevice[] = {  {&_swigt__p_FIX__OrderInputDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderPercent[] = {  {&_swigt__p_FIX__OrderPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderQty[] = {  {&_swigt__p_FIX__OrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderQty2[] = {  {&_swigt__p_FIX__OrderQty2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderRestrictions[] = {  {&_swigt__p_FIX__OrderRestrictions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigClOrdID[] = {  {&_swigt__p_FIX__OrigClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigCrossID[] = {  {&_swigt__p_FIX__OrigCrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigCustOrderCapacity[] = {  {&_swigt__p_FIX__OrigCustOrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigOrdModTime[] = {  {&_swigt__p_FIX__OrigOrdModTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigPosReqRefID[] = {  {&_swigt__p_FIX__OrigPosReqRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigSecondaryTradeID[] = {  {&_swigt__p_FIX__OrigSecondaryTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigSendingTime[] = {  {&_swigt__p_FIX__OrigSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTime[] = {  {&_swigt__p_FIX__OrigTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeDate[] = {  {&_swigt__p_FIX__OrigTradeDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeHandlingInstr[] = {  {&_swigt__p_FIX__OrigTradeHandlingInstr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeID[] = {  {&_swigt__p_FIX__OrigTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OriginalNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OutMainCntryUIndex[] = {  {&_swigt__p_FIX__OutMainCntryUIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OutsideIndexPct[] = {  {&_swigt__p_FIX__OutsideIndexPct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OwnerType[] = {  {&_swigt__p_FIX__OwnerType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OwnershipType[] = {  {&_swigt__p_FIX__OwnershipType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PERCENTAGE[] = {  {&_swigt__p_FIX__PERCENTAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PRICE[] = {  {&_swigt__p_FIX__PRICE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PRICEOFFSET[] = {  {&_swigt__p_FIX__PRICEOFFSET, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ParentMktSegmID[] = {  {&_swigt__p_FIX__ParentMktSegmID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ParticipationRate[] = {  {&_swigt__p_FIX__ParticipationRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyAltID[] = {  {&_swigt__p_FIX__PartyAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyAltIDSource[] = {  {&_swigt__p_FIX__PartyAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyAltSubID[] = {  {&_swigt__p_FIX__PartyAltSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyAltSubIDType[] = {  {&_swigt__p_FIX__PartyAltSubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyDetailsListReportID[] = {  {&_swigt__p_FIX__PartyDetailsListReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyDetailsListRequestID[] = {  {&_swigt__p_FIX__PartyDetailsListRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyDetailsRequestResult[] = {  {&_swigt__p_FIX__PartyDetailsRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyID[] = {  {&_swigt__p_FIX__PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyIDSource[] = {  {&_swigt__p_FIX__PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyListResponseType[] = {  {&_swigt__p_FIX__PartyListResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyRelationship[] = {  {&_swigt__p_FIX__PartyRelationship, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyRole[] = {  {&_swigt__p_FIX__PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartySubID[] = {  {&_swigt__p_FIX__PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartySubIDType[] = {  {&_swigt__p_FIX__PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Password[] = {  {&_swigt__p_FIX__Password, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentDate[] = {  {&_swigt__p_FIX__PaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentMethod[] = {  {&_swigt__p_FIX__PaymentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentRef[] = {  {&_swigt__p_FIX__PaymentRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentRemitterID[] = {  {&_swigt__p_FIX__PaymentRemitterID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PctAtRisk[] = {  {&_swigt__p_FIX__PctAtRisk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegDifference[] = {  {&_swigt__p_FIX__PegDifference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegLimitType[] = {  {&_swigt__p_FIX__PegLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegMoveType[] = {  {&_swigt__p_FIX__PegMoveType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegOffsetType[] = {  {&_swigt__p_FIX__PegOffsetType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegOffsetValue[] = {  {&_swigt__p_FIX__PegOffsetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegPriceType[] = {  {&_swigt__p_FIX__PegPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegRoundDirection[] = {  {&_swigt__p_FIX__PegRoundDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegScope[] = {  {&_swigt__p_FIX__PegScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityDesc[] = {  {&_swigt__p_FIX__PegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityID[] = {  {&_swigt__p_FIX__PegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityIDSource[] = {  {&_swigt__p_FIX__PegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSymbol[] = {  {&_swigt__p_FIX__PegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PeggedPrice[] = {  {&_swigt__p_FIX__PeggedPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PeggedRefPrice[] = {  {&_swigt__p_FIX__PeggedRefPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Pool[] = {  {&_swigt__p_FIX__Pool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosAmt[] = {  {&_swigt__p_FIX__PosAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosAmtType[] = {  {&_swigt__p_FIX__PosAmtType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintAction[] = {  {&_swigt__p_FIX__PosMaintAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintResult[] = {  {&_swigt__p_FIX__PosMaintResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintRptID[] = {  {&_swigt__p_FIX__PosMaintRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintRptRefID[] = {  {&_swigt__p_FIX__PosMaintRptRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintStatus[] = {  {&_swigt__p_FIX__PosMaintStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosQtyStatus[] = {  {&_swigt__p_FIX__PosQtyStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqID[] = {  {&_swigt__p_FIX__PosReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqResult[] = {  {&_swigt__p_FIX__PosReqResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqStatus[] = {  {&_swigt__p_FIX__PosReqStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqType[] = {  {&_swigt__p_FIX__PosReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosTransType[] = {  {&_swigt__p_FIX__PosTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosType[] = {  {&_swigt__p_FIX__PosType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionCurrency[] = {  {&_swigt__p_FIX__PositionCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionEffect[] = {  {&_swigt__p_FIX__PositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionLimit[] = {  {&_swigt__p_FIX__PositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PossDupFlag[] = {  {&_swigt__p_FIX__PossDupFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PossResend[] = {  {&_swigt__p_FIX__PossResend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreTradeAnonymity[] = {  {&_swigt__p_FIX__PreTradeAnonymity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreallocMethod[] = {  {&_swigt__p_FIX__PreallocMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PrevClosePx[] = {  {&_swigt__p_FIX__PrevClosePx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreviouslyReported[] = {  {&_swigt__p_FIX__PreviouslyReported, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Price[] = {  {&_swigt__p_FIX__Price, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Price2[] = {  {&_swigt__p_FIX__Price2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceDelta[] = {  {&_swigt__p_FIX__PriceDelta, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceImprovement[] = {  {&_swigt__p_FIX__PriceImprovement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceLimitType[] = {  {&_swigt__p_FIX__PriceLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceProtectionScope[] = {  {&_swigt__p_FIX__PriceProtectionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceQuoteMethod[] = {  {&_swigt__p_FIX__PriceQuoteMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceType[] = {  {&_swigt__p_FIX__PriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceUnitOfMeasure[] = {  {&_swigt__p_FIX__PriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__PriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorSettlPrice[] = {  {&_swigt__p_FIX__PriorSettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorSpreadIndicator[] = {  {&_swigt__p_FIX__PriorSpreadIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorityIndicator[] = {  {&_swigt__p_FIX__PriorityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PrivateQuote[] = {  {&_swigt__p_FIX__PrivateQuote, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProcessCode[] = {  {&_swigt__p_FIX__ProcessCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Product[] = {  {&_swigt__p_FIX__Product, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProductComplex[] = {  {&_swigt__p_FIX__ProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProgPeriodInterval[] = {  {&_swigt__p_FIX__ProgPeriodInterval, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProgRptReqs[] = {  {&_swigt__p_FIX__ProgRptReqs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PublishTrdIndicator[] = {  {&_swigt__p_FIX__PublishTrdIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PutOrCall[] = {  {&_swigt__p_FIX__PutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QTY[] = {  {&_swigt__p_FIX__QTY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QtyType[] = {  {&_swigt__p_FIX__QtyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Quantity[] = {  {&_swigt__p_FIX__Quantity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuantityDate[] = {  {&_swigt__p_FIX__QuantityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuantityType[] = {  {&_swigt__p_FIX__QuantityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteAckStatus[] = {  {&_swigt__p_FIX__QuoteAckStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteCancelType[] = {  {&_swigt__p_FIX__QuoteCancelType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteCondition[] = {  {&_swigt__p_FIX__QuoteCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryID[] = {  {&_swigt__p_FIX__QuoteEntryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryRejectReason[] = {  {&_swigt__p_FIX__QuoteEntryRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryStatus[] = {  {&_swigt__p_FIX__QuoteEntryStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteID[] = {  {&_swigt__p_FIX__QuoteID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteMsgID[] = {  {&_swigt__p_FIX__QuoteMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuotePriceType[] = {  {&_swigt__p_FIX__QuotePriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteQualifier[] = {  {&_swigt__p_FIX__QuoteQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRejectReason[] = {  {&_swigt__p_FIX__QuoteRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteReqID[] = {  {&_swigt__p_FIX__QuoteReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRequestRejectReason[] = {  {&_swigt__p_FIX__QuoteRequestRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRequestType[] = {  {&_swigt__p_FIX__QuoteRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRespID[] = {  {&_swigt__p_FIX__QuoteRespID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRespType[] = {  {&_swigt__p_FIX__QuoteRespType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteResponseLevel[] = {  {&_swigt__p_FIX__QuoteResponseLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteSetID[] = {  {&_swigt__p_FIX__QuoteSetID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteSetValidUntilTime[] = {  {&_swigt__p_FIX__QuoteSetValidUntilTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteStatus[] = {  {&_swigt__p_FIX__QuoteStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteStatusReqID[] = {  {&_swigt__p_FIX__QuoteStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteType[] = {  {&_swigt__p_FIX__QuoteType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RFQReqID[] = {  {&_swigt__p_FIX__RFQReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RateSource[] = {  {&_swigt__p_FIX__RateSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RateSourceType[] = {  {&_swigt__p_FIX__RateSourceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RatioQty[] = {  {&_swigt__p_FIX__RatioQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RawData[] = {  {&_swigt__p_FIX__RawData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RawDataLength[] = {  {&_swigt__p_FIX__RawDataLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReceivedDeptID[] = {  {&_swigt__p_FIX__ReceivedDeptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RedemptionDate[] = {  {&_swigt__p_FIX__RedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefAllocID[] = {  {&_swigt__p_FIX__RefAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplExtID[] = {  {&_swigt__p_FIX__RefApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplID[] = {  {&_swigt__p_FIX__RefApplID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplLastSeqNum[] = {  {&_swigt__p_FIX__RefApplLastSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplReqID[] = {  {&_swigt__p_FIX__RefApplReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplVerID[] = {  {&_swigt__p_FIX__RefApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefCompID[] = {  {&_swigt__p_FIX__RefCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefCstmApplVerID[] = {  {&_swigt__p_FIX__RefCstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefMsgType[] = {  {&_swigt__p_FIX__RefMsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrdIDReason[] = {  {&_swigt__p_FIX__RefOrdIDReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrderID[] = {  {&_swigt__p_FIX__RefOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrderIDSource[] = {  {&_swigt__p_FIX__RefOrderIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefSeqNum[] = {  {&_swigt__p_FIX__RefSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefSubID[] = {  {&_swigt__p_FIX__RefSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefTagID[] = {  {&_swigt__p_FIX__RefTagID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReferencePage[] = {  {&_swigt__p_FIX__ReferencePage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefreshIndicator[] = {  {&_swigt__p_FIX__RefreshIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefreshQty[] = {  {&_swigt__p_FIX__RefreshQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistAcctType[] = {  {&_swigt__p_FIX__RegistAcctType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistDetls[] = {  {&_swigt__p_FIX__RegistDetls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistDtls[] = {  {&_swigt__p_FIX__RegistDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistEmail[] = {  {&_swigt__p_FIX__RegistEmail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistID[] = {  {&_swigt__p_FIX__RegistID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRefID[] = {  {&_swigt__p_FIX__RegistRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRejReasonCode[] = {  {&_swigt__p_FIX__RegistRejReasonCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRejReasonText[] = {  {&_swigt__p_FIX__RegistRejReasonText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistStatus[] = {  {&_swigt__p_FIX__RegistStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistTransType[] = {  {&_swigt__p_FIX__RegistTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RejectLogon[] = {  {&_swigt__p_FIX__RejectLogon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RejectText[] = {  {&_swigt__p_FIX__RejectText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelSymTransactTime[] = {  {&_swigt__p_FIX__RelSymTransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatdSym[] = {  {&_swigt__p_FIX__RelatdSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartyID[] = {  {&_swigt__p_FIX__RelatedContextPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartyIDSource[] = {  {&_swigt__p_FIX__RelatedContextPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartyRole[] = {  {&_swigt__p_FIX__RelatedContextPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartySubID[] = {  {&_swigt__p_FIX__RelatedContextPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedContextPartySubIDType[] = {  {&_swigt__p_FIX__RelatedContextPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltID[] = {  {&_swigt__p_FIX__RelatedPartyAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltIDSource[] = {  {&_swigt__p_FIX__RelatedPartyAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltSubID[] = {  {&_swigt__p_FIX__RelatedPartyAltSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyAltSubIDType[] = {  {&_swigt__p_FIX__RelatedPartyAltSubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyID[] = {  {&_swigt__p_FIX__RelatedPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyIDSource[] = {  {&_swigt__p_FIX__RelatedPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartyRole[] = {  {&_swigt__p_FIX__RelatedPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartySubID[] = {  {&_swigt__p_FIX__RelatedPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatedPartySubIDType[] = {  {&_swigt__p_FIX__RelatedPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskCFICode[] = {  {&_swigt__p_FIX__RelationshipRiskCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskCouponRate[] = {  {&_swigt__p_FIX__RelationshipRiskCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskEncodedSecurityDesc[] = {  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskEncodedSecurityDescLen[] = {  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskFlexibleIndicator[] = {  {&_swigt__p_FIX__RelationshipRiskFlexibleIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskInstrumentMultiplier[] = {  {&_swigt__p_FIX__RelationshipRiskInstrumentMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskInstrumentOperator[] = {  {&_swigt__p_FIX__RelationshipRiskInstrumentOperator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskInstrumentSettlType[] = {  {&_swigt__p_FIX__RelationshipRiskInstrumentSettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitAmount[] = {  {&_swigt__p_FIX__RelationshipRiskLimitAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitCurrency[] = {  {&_swigt__p_FIX__RelationshipRiskLimitCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitPlatform[] = {  {&_swigt__p_FIX__RelationshipRiskLimitPlatform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskLimitType[] = {  {&_swigt__p_FIX__RelationshipRiskLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskMaturityMonthYear[] = {  {&_swigt__p_FIX__RelationshipRiskMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskMaturityTime[] = {  {&_swigt__p_FIX__RelationshipRiskMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskProduct[] = {  {&_swigt__p_FIX__RelationshipRiskProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskProductComplex[] = {  {&_swigt__p_FIX__RelationshipRiskProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskPutOrCall[] = {  {&_swigt__p_FIX__RelationshipRiskPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskRestructuringType[] = {  {&_swigt__p_FIX__RelationshipRiskRestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityAltID[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityAltIDSource[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityDesc[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityExchange[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityGroup[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityID[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityIDSource[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecuritySubType[] = {  {&_swigt__p_FIX__RelationshipRiskSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSecurityType[] = {  {&_swigt__p_FIX__RelationshipRiskSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSeniority[] = {  {&_swigt__p_FIX__RelationshipRiskSeniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSymbol[] = {  {&_swigt__p_FIX__RelationshipRiskSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskSymbolSfx[] = {  {&_swigt__p_FIX__RelationshipRiskSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskWarningLevelName[] = {  {&_swigt__p_FIX__RelationshipRiskWarningLevelName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelationshipRiskWarningLevelPercent[] = {  {&_swigt__p_FIX__RelationshipRiskWarningLevelPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepeatedTag[] = {  {&_swigt__p_FIX__RepeatedTag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepeatingGroupCountMismatch[] = {  {&_swigt__p_FIX__RepeatingGroupCountMismatch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepoCollateralSecurityType[] = {  {&_swigt__p_FIX__RepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportToExch[] = {  {&_swigt__p_FIX__ReportToExch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportedPx[] = {  {&_swigt__p_FIX__ReportedPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportedPxDiff[] = {  {&_swigt__p_FIX__ReportedPxDiff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepurchaseRate[] = {  {&_swigt__p_FIX__RepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepurchaseTerm[] = {  {&_swigt__p_FIX__RepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RequestedPartyRole[] = {  {&_swigt__p_FIX__RequestedPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RequiredTagMissing[] = {  {&_swigt__p_FIX__RequiredTagMissing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResetSeqNumFlag[] = {  {&_swigt__p_FIX__ResetSeqNumFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RespondentType[] = {  {&_swigt__p_FIX__RespondentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResponseDestination[] = {  {&_swigt__p_FIX__ResponseDestination, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResponseTransportType[] = {  {&_swigt__p_FIX__ResponseTransportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RestructuringType[] = {  {&_swigt__p_FIX__RestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReversalIndicator[] = {  {&_swigt__p_FIX__ReversalIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskCFICode[] = {  {&_swigt__p_FIX__RiskCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskCouponRate[] = {  {&_swigt__p_FIX__RiskCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskEncodedSecurityDesc[] = {  {&_swigt__p_FIX__RiskEncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskEncodedSecurityDescLen[] = {  {&_swigt__p_FIX__RiskEncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskFlexibleIndicator[] = {  {&_swigt__p_FIX__RiskFlexibleIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskFreeRate[] = {  {&_swigt__p_FIX__RiskFreeRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskInstrumentMultiplier[] = {  {&_swigt__p_FIX__RiskInstrumentMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskInstrumentOperator[] = {  {&_swigt__p_FIX__RiskInstrumentOperator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskInstrumentSettlType[] = {  {&_swigt__p_FIX__RiskInstrumentSettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitAmount[] = {  {&_swigt__p_FIX__RiskLimitAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitCurrency[] = {  {&_swigt__p_FIX__RiskLimitCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitPlatform[] = {  {&_swigt__p_FIX__RiskLimitPlatform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskLimitType[] = {  {&_swigt__p_FIX__RiskLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskMaturityMonthYear[] = {  {&_swigt__p_FIX__RiskMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskMaturityTime[] = {  {&_swigt__p_FIX__RiskMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskProduct[] = {  {&_swigt__p_FIX__RiskProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskProductComplex[] = {  {&_swigt__p_FIX__RiskProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskPutOrCall[] = {  {&_swigt__p_FIX__RiskPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskRestructuringType[] = {  {&_swigt__p_FIX__RiskRestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityAltID[] = {  {&_swigt__p_FIX__RiskSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityAltIDSource[] = {  {&_swigt__p_FIX__RiskSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityDesc[] = {  {&_swigt__p_FIX__RiskSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityExchange[] = {  {&_swigt__p_FIX__RiskSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityGroup[] = {  {&_swigt__p_FIX__RiskSecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityID[] = {  {&_swigt__p_FIX__RiskSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityIDSource[] = {  {&_swigt__p_FIX__RiskSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecuritySubType[] = {  {&_swigt__p_FIX__RiskSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSecurityType[] = {  {&_swigt__p_FIX__RiskSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSeniority[] = {  {&_swigt__p_FIX__RiskSeniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSymbol[] = {  {&_swigt__p_FIX__RiskSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskSymbolSfx[] = {  {&_swigt__p_FIX__RiskSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskWarningLevelName[] = {  {&_swigt__p_FIX__RiskWarningLevelName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskWarningLevelPercent[] = {  {&_swigt__p_FIX__RiskWarningLevelPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RndPx[] = {  {&_swigt__p_FIX__RndPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyID[] = {  {&_swigt__p_FIX__RootPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyIDSource[] = {  {&_swigt__p_FIX__RootPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyRole[] = {  {&_swigt__p_FIX__RootPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartySubID[] = {  {&_swigt__p_FIX__RootPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartySubIDType[] = {  {&_swigt__p_FIX__RootPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundLot[] = {  {&_swigt__p_FIX__RoundLot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundingDirection[] = {  {&_swigt__p_FIX__RoundingDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundingModulus[] = {  {&_swigt__p_FIX__RoundingModulus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoutingID[] = {  {&_swigt__p_FIX__RoutingID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoutingType[] = {  {&_swigt__p_FIX__RoutingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RptSeq[] = {  {&_swigt__p_FIX__RptSeq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RptSys[] = {  {&_swigt__p_FIX__RptSys, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Rule80A[] = {  {&_swigt__p_FIX__Rule80A, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RuntimeError[] = {  {&_swigt__p_FIX__RuntimeError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SEQNUM[] = {  {&_swigt__p_FIX__SEQNUM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__STRING[] = {  {&_swigt__p_FIX__STRING, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Scope[] = {  {&_swigt__p_FIX__Scope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ScreenLog[] = {  {&_swigt__p_FIX__ScreenLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ScreenLogFactory[] = {  {&_swigt__p_FIX__ScreenLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecDefStatus[] = {  {&_swigt__p_FIX__SecDefStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryAllocID[] = {  {&_swigt__p_FIX__SecondaryAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryClOrdID[] = {  {&_swigt__p_FIX__SecondaryClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryDisplayQty[] = {  {&_swigt__p_FIX__SecondaryDisplayQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryExecID[] = {  {&_swigt__p_FIX__SecondaryExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryFirmTradeID[] = {  {&_swigt__p_FIX__SecondaryFirmTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryHighLimitPrice[] = {  {&_swigt__p_FIX__SecondaryHighLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryIndividualAllocID[] = {  {&_swigt__p_FIX__SecondaryIndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryLowLimitPrice[] = {  {&_swigt__p_FIX__SecondaryLowLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryOrderID[] = {  {&_swigt__p_FIX__SecondaryOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryPriceLimitType[] = {  {&_swigt__p_FIX__SecondaryPriceLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeID[] = {  {&_swigt__p_FIX__SecondaryTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeReportID[] = {  {&_swigt__p_FIX__SecondaryTradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeReportRefID[] = {  {&_swigt__p_FIX__SecondaryTradeReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradingReferencePrice[] = {  {&_swigt__p_FIX__SecondaryTradingReferencePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTrdType[] = {  {&_swigt__p_FIX__SecondaryTrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecureData[] = {  {&_swigt__p_FIX__SecureData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecureDataLen[] = {  {&_swigt__p_FIX__SecureDataLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityAltID[] = {  {&_swigt__p_FIX__SecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityAltIDSource[] = {  {&_swigt__p_FIX__SecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityDesc[] = {  {&_swigt__p_FIX__SecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityExchange[] = {  {&_swigt__p_FIX__SecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityGroup[] = {  {&_swigt__p_FIX__SecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityID[] = {  {&_swigt__p_FIX__SecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityIDSource[] = {  {&_swigt__p_FIX__SecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListDesc[] = {  {&_swigt__p_FIX__SecurityListDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListID[] = {  {&_swigt__p_FIX__SecurityListID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListRefID[] = {  {&_swigt__p_FIX__SecurityListRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListRequestType[] = {  {&_swigt__p_FIX__SecurityListRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListType[] = {  {&_swigt__p_FIX__SecurityListType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListTypeSource[] = {  {&_swigt__p_FIX__SecurityListTypeSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityReportID[] = {  {&_swigt__p_FIX__SecurityReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityReqID[] = {  {&_swigt__p_FIX__SecurityReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityRequestResult[] = {  {&_swigt__p_FIX__SecurityRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityRequestType[] = {  {&_swigt__p_FIX__SecurityRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityResponseID[] = {  {&_swigt__p_FIX__SecurityResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityResponseType[] = {  {&_swigt__p_FIX__SecurityResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentAcctName[] = {  {&_swigt__p_FIX__SecuritySettlAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentAcctNum[] = {  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentCode[] = {  {&_swigt__p_FIX__SecuritySettlAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentContactName[] = {  {&_swigt__p_FIX__SecuritySettlAgentContactName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentContactPhone[] = {  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentName[] = {  {&_swigt__p_FIX__SecuritySettlAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityStatus[] = {  {&_swigt__p_FIX__SecurityStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityStatusReqID[] = {  {&_swigt__p_FIX__SecurityStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySubType[] = {  {&_swigt__p_FIX__SecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityTradingEvent[] = {  {&_swigt__p_FIX__SecurityTradingEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityTradingStatus[] = {  {&_swigt__p_FIX__SecurityTradingStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityType[] = {  {&_swigt__p_FIX__SecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityUpdateAction[] = {  {&_swigt__p_FIX__SecurityUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXML[] = {  {&_swigt__p_FIX__SecurityXML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXMLLen[] = {  {&_swigt__p_FIX__SecurityXMLLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXMLSchema[] = {  {&_swigt__p_FIX__SecurityXMLSchema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SellVolume[] = {  {&_swigt__p_FIX__SellVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SellerDays[] = {  {&_swigt__p_FIX__SellerDays, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderCompID[] = {  {&_swigt__p_FIX__SenderCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderLocationID[] = {  {&_swigt__p_FIX__SenderLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderSubID[] = {  {&_swigt__p_FIX__SenderSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SendingDate[] = {  {&_swigt__p_FIX__SendingDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SendingTime[] = {  {&_swigt__p_FIX__SendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Seniority[] = {  {&_swigt__p_FIX__Seniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Session[] = {  {&_swigt__p_FIX__Session, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionID[] = {  {&_swigt__p_FIX__SessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionNotFound[] = {  {&_swigt__p_FIX__SessionNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionRejectReason[] = {  {&_swigt__p_FIX__SessionRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionSettings[] = {  {&_swigt__p_FIX__SessionSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionStatus[] = {  {&_swigt__p_FIX__SessionStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlBrkrCode[] = {  {&_swigt__p_FIX__SettlBrkrCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrAmt[] = {  {&_swigt__p_FIX__SettlCurrAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrBidFxRate[] = {  {&_swigt__p_FIX__SettlCurrBidFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrFxRate[] = {  {&_swigt__p_FIX__SettlCurrFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrFxRateCalc[] = {  {&_swigt__p_FIX__SettlCurrFxRateCalc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrOfferFxRate[] = {  {&_swigt__p_FIX__SettlCurrOfferFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrency[] = {  {&_swigt__p_FIX__SettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDate[] = {  {&_swigt__p_FIX__SettlDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDate2[] = {  {&_swigt__p_FIX__SettlDate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDeliveryType[] = {  {&_swigt__p_FIX__SettlDeliveryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDepositoryCode[] = {  {&_swigt__p_FIX__SettlDepositoryCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstCode[] = {  {&_swigt__p_FIX__SettlInstCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstID[] = {  {&_swigt__p_FIX__SettlInstID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstMode[] = {  {&_swigt__p_FIX__SettlInstMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstMsgID[] = {  {&_swigt__p_FIX__SettlInstMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstRefID[] = {  {&_swigt__p_FIX__SettlInstRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstReqID[] = {  {&_swigt__p_FIX__SettlInstReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstReqRejCode[] = {  {&_swigt__p_FIX__SettlInstReqRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstSource[] = {  {&_swigt__p_FIX__SettlInstSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstTransType[] = {  {&_swigt__p_FIX__SettlInstTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlLocation[] = {  {&_swigt__p_FIX__SettlLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlMethod[] = {  {&_swigt__p_FIX__SettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligID[] = {  {&_swigt__p_FIX__SettlObligID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligMode[] = {  {&_swigt__p_FIX__SettlObligMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligMsgID[] = {  {&_swigt__p_FIX__SettlObligMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligRefID[] = {  {&_swigt__p_FIX__SettlObligRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligSource[] = {  {&_swigt__p_FIX__SettlObligSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligTransType[] = {  {&_swigt__p_FIX__SettlObligTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyID[] = {  {&_swigt__p_FIX__SettlPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyIDSource[] = {  {&_swigt__p_FIX__SettlPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyRole[] = {  {&_swigt__p_FIX__SettlPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartySubID[] = {  {&_swigt__p_FIX__SettlPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartySubIDType[] = {  {&_swigt__p_FIX__SettlPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPrice[] = {  {&_swigt__p_FIX__SettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPriceType[] = {  {&_swigt__p_FIX__SettlPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlSessID[] = {  {&_swigt__p_FIX__SettlSessID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlSessSubID[] = {  {&_swigt__p_FIX__SettlSessSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlType[] = {  {&_swigt__p_FIX__SettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettleOnOpenFlag[] = {  {&_swigt__p_FIX__SettleOnOpenFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlementCycleNo[] = {  {&_swigt__p_FIX__SettlementCycleNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlmntTyp[] = {  {&_swigt__p_FIX__SettlmntTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SharedCommission[] = {  {&_swigt__p_FIX__SharedCommission, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Shares[] = {  {&_swigt__p_FIX__Shares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ShortQty[] = {  {&_swigt__p_FIX__ShortQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ShortSaleReason[] = {  {&_swigt__p_FIX__ShortSaleReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Side[] = {  {&_swigt__p_FIX__Side, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideComplianceID[] = {  {&_swigt__p_FIX__SideComplianceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideCurrency[] = {  {&_swigt__p_FIX__SideCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideExecID[] = {  {&_swigt__p_FIX__SideExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideFillStationCd[] = {  {&_swigt__p_FIX__SideFillStationCd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideGrossTradeAmt[] = {  {&_swigt__p_FIX__SideGrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideLastQty[] = {  {&_swigt__p_FIX__SideLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideLiquidityInd[] = {  {&_swigt__p_FIX__SideLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideMultiLegReportingType[] = {  {&_swigt__p_FIX__SideMultiLegReportingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideQty[] = {  {&_swigt__p_FIX__SideQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideReasonCd[] = {  {&_swigt__p_FIX__SideReasonCd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideSettlCurrency[] = {  {&_swigt__p_FIX__SideSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTimeInForce[] = {  {&_swigt__p_FIX__SideTimeInForce, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTradeReportID[] = {  {&_swigt__p_FIX__SideTradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestamp[] = {  {&_swigt__p_FIX__SideTrdRegTimestamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestampSrc[] = {  {&_swigt__p_FIX__SideTrdRegTimestampSrc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestampType[] = {  {&_swigt__p_FIX__SideTrdRegTimestampType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdSubTyp[] = {  {&_swigt__p_FIX__SideTrdSubTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValue1[] = {  {&_swigt__p_FIX__SideValue1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValue2[] = {  {&_swigt__p_FIX__SideValue2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValueInd[] = {  {&_swigt__p_FIX__SideValueInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Signature[] = {  {&_swigt__p_FIX__Signature, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SignatureLength[] = {  {&_swigt__p_FIX__SignatureLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketAcceptor[] = {  {&_swigt__p_FIX__SocketAcceptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketCloseFailed[] = {  {&_swigt__p_FIX__SocketCloseFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketException[] = {  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketException, 0, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__SocketException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketInitiator[] = {  {&_swigt__p_FIX__SocketInitiator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketRecvFailed[] = {  {&_swigt__p_FIX__SocketRecvFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketSendFailed[] = {  {&_swigt__p_FIX__SocketSendFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SolicitedFlag[] = {  {&_swigt__p_FIX__SolicitedFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Spread[] = {  {&_swigt__p_FIX__Spread, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SpreadToBenchmark[] = {  {&_swigt__p_FIX__SpreadToBenchmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbID[] = {  {&_swigt__p_FIX__StandInstDbID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbName[] = {  {&_swigt__p_FIX__StandInstDbName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbType[] = {  {&_swigt__p_FIX__StandInstDbType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartCash[] = {  {&_swigt__p_FIX__StartCash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartDate[] = {  {&_swigt__p_FIX__StartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartMaturityMonthYear[] = {  {&_swigt__p_FIX__StartMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartStrikePxRange[] = {  {&_swigt__p_FIX__StartStrikePxRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartTickPriceRange[] = {  {&_swigt__p_FIX__StartTickPriceRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__StateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatsType[] = {  {&_swigt__p_FIX__StatsType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatusText[] = {  {&_swigt__p_FIX__StatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatusValue[] = {  {&_swigt__p_FIX__StatusValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StipulationType[] = {  {&_swigt__p_FIX__StipulationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StipulationValue[] = {  {&_swigt__p_FIX__StipulationValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StopPx[] = {  {&_swigt__p_FIX__StopPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterName[] = {  {&_swigt__p_FIX__StrategyParameterName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterType[] = {  {&_swigt__p_FIX__StrategyParameterType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterValue[] = {  {&_swigt__p_FIX__StrategyParameterValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnAckType[] = {  {&_swigt__p_FIX__StreamAsgnAckType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnRejReason[] = {  {&_swigt__p_FIX__StreamAsgnRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnReqID[] = {  {&_swigt__p_FIX__StreamAsgnReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnReqType[] = {  {&_swigt__p_FIX__StreamAsgnReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnRptID[] = {  {&_swigt__p_FIX__StreamAsgnRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnType[] = {  {&_swigt__p_FIX__StreamAsgnType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeCurrency[] = {  {&_swigt__p_FIX__StrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeExerciseStyle[] = {  {&_swigt__p_FIX__StrikeExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeIncrement[] = {  {&_swigt__p_FIX__StrikeIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeMultiplier[] = {  {&_swigt__p_FIX__StrikeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePrice[] = {  {&_swigt__p_FIX__StrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceBoundaryMethod[] = {  {&_swigt__p_FIX__StrikePriceBoundaryMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceBoundaryPrecision[] = {  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceDeterminationMethod[] = {  {&_swigt__p_FIX__StrikePriceDeterminationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeRuleID[] = {  {&_swigt__p_FIX__StrikeRuleID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeTime[] = {  {&_swigt__p_FIX__StrikeTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeValue[] = {  {&_swigt__p_FIX__StrikeValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StringField[] = {  {&_swigt__p_FIX__DeliveryDate, _p_FIX__DeliveryDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RFQReqID, _p_FIX__RFQReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedText, _p_FIX__EncodedTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BidID, _p_FIX__BidIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeCondition, _p_FIX__TradeConditionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteCondition, _p_FIX__QuoteConditionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExchangeRule, _p_FIX__ExchangeRuleTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FutSettDate2, _p_FIX__FutSettDate2To_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollAsgnID, _p_FIX__CollAsgnIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeRequestID, _p_FIX__TradeRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UserRequestID, _p_FIX__UserRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NetworkRequestID, _p_FIX__NetworkRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyDetailsListRequestID, _p_FIX__PartyDetailsListRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClientBidID, _p_FIX__ClientBidIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ReferencePage, _p_FIX__ReferencePageTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Text, _p_FIX__TextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDFeedType, _p_FIX__MDFeedTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UserStatusText, _p_FIX__UserStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StatusText, _p_FIX__StatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListStatusText, _p_FIX__ListStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedListStatusText, _p_FIX__EncodedListStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIid, _p_FIX__IOIidTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDate, _p_FIX__SettlDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSettlDate, _p_FIX__LegSettlDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskType, _p_FIX__DeskTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasure, _p_FIX__PriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnitOfMeasure, _p_FIX__UnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, _p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasure, _p_FIX__DerivativeUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasure, _p_FIX__LegPriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasure, _p_FIX__LegUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, _p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, _p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TransferReason, _p_FIX__TransferReasonTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegInstrRegistry, _p_FIX__LegInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrRegistry, _p_FIX__InstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrRegistry, _p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrRegistry, _p_FIX__UnderlyingInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityDesc, _p_FIX__DerivativeSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityDesc, _p_FIX__TriggerSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityDesc, _p_FIX__PegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, _p_FIX__UnderlyingLegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityDesc, _p_FIX__RelationshipRiskSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskEncodedSecurityDesc, _p_FIX__RiskEncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityDesc, _p_FIX__SecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, _p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDesc, _p_FIX__EncodedLegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskEncodedSecurityDesc, _p_FIX__RelationshipRiskEncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityDesc, _p_FIX__RiskSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Username, _p_FIX__UsernameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistRejReasonText, _p_FIX__RegistRejReasonTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlBrkrCode, _p_FIX__SettlBrkrCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplID, _p_FIX__RefApplIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplID, _p_FIX__ApplIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Pool, _p_FIX__PoolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampSrc, _p_FIX__SideTrdRegTimestampSrcTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SendingDate, _p_FIX__SendingDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskLimitPlatform, _p_FIX__RiskLimitPlatformTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitPlatform, _p_FIX__RelationshipRiskLimitPlatformTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartyID, _p_FIX__RelatedContextPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedPartyID, _p_FIX__RelatedPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContextPartyID, _p_FIX__ContextPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested4PartyID, _p_FIX__Nested4PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyID, _p_FIX__PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RootPartyID, _p_FIX__RootPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetPartyID, _p_FIX__TargetPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyID, _p_FIX__UndlyInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyID, _p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyID, _p_FIX__InstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested2PartyID, _p_FIX__Nested2PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollInquiryID, _p_FIX__CollInquiryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlSessID, _p_FIX__SettlSessIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketSegmentDesc, _p_FIX__MarketSegmentDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementDesc, _p_FIX__AgreementDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteReqID, _p_FIX__QuoteReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FillExecID, _p_FIX__FillExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecID, _p_FIX__ExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryExecID, _p_FIX__SecondaryExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideExecID, _p_FIX__SideExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentName, _p_FIX__CashSettlAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentName, _p_FIX__CashDistribAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentName, _p_FIX__SecuritySettlAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryOriginator, _p_FIX__MDEntryOriginatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStipulationType, _p_FIX__LegStipulationTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StipulationType, _p_FIX__StipulationTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstCode, _p_FIX__SettlInstCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MailingDtls, _p_FIX__MailingDtlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityAltID, _p_FIX__LegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltID, _p_FIX__RelatedPartyAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityAltID, _p_FIX__RelationshipRiskSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyAltID, _p_FIX__PartyAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, _p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltID, _p_FIX__DerivativeSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltID, _p_FIX__UnderlyingSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityAltID, _p_FIX__RiskSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedAllocText, _p_FIX__EncodedAllocTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocText, _p_FIX__AllocTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClientID, _p_FIX__ClientIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetSubID, _p_FIX__TargetSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyAltSubID, _p_FIX__PartyAltSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedPartyAltSubID, _p_FIX__RelatedPartyAltSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatdSym, _p_FIX__RelatdSymTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactName, _p_FIX__SecuritySettlAgentContactNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctName, _p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctName, _p_FIX__CashDistribAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctName, _p_FIX__CashSettlAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactName, _p_FIX__CashSettlAgentContactNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplVerID, _p_FIX__ApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefCstmApplVerID, _p_FIX__RefCstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DefaultApplVerID, _p_FIX__DefaultApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CstmApplVerID, _p_FIX__CstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplVerID, _p_FIX__RefApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DefaultCstmApplVerID, _p_FIX__DefaultCstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Country, _p_FIX__CountryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardHolderName, _p_FIX__CardHolderNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrategyParameterName, _p_FIX__StrategyParameterNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderLocationID, _p_FIX__SenderLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LocationID, _p_FIX__LocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetLocationID, _p_FIX__TargetLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfLocationID, _p_FIX__OnBehalfOfLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToLocationID, _p_FIX__DeliverToLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeInputDevice, _p_FIX__TradeInputDeviceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderInputDevice, _p_FIX__OrderInputDeviceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessCurr, _p_FIX__AllowableOneSidednessCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocSettlCurrency, _p_FIX__LegAllocSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PositionCurrency, _p_FIX__PositionCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrency, _p_FIX__UnderlyingCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CommCurrency, _p_FIX__CommCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikeCurrency, _p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeCurrency, _p_FIX__DerivativeStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementCurrency, _p_FIX__AgreementCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrency, _p_FIX__AllocSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingCurrency, _p_FIX__TradingCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Currency, _p_FIX__CurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrikeCurrency, _p_FIX__StrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlCurrency, _p_FIX__SettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSettlCurrency, _p_FIX__LegSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCurrency, _p_FIX__LegCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideCurrency, _p_FIX__SideCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveCurrency, _p_FIX__BenchmarkCurveCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, _p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideSettlCurrency, _p_FIX__SideSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskLimitCurrency, _p_FIX__RiskLimitCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskLimitCurrency, _p_FIX__RelationshipRiskLimitCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStrikeCurrency, _p_FIX__LegStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingFeeIndicator, _p_FIX__ClearingFeeIndicatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocClearingFeeIndicator, _p_FIX__AllocClearingFeeIndicatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FinancialStatus, _p_FIX__FinancialStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementStatus, _p_FIX__UnderlyingSettlementStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocCustomerCapacity, _p_FIX__AllocCustomerCapacityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityStatus, _p_FIX__SecurityStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityStatus, _p_FIX__DerivativeSecurityStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDReqID, _p_FIX__MDReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryRefID, _p_FIX__MDEntryRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Signature, _p_FIX__SignatureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StandInstDbID, _p_FIX__StandInstDbIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstMsgID, _p_FIX__SettlInstMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BrokerOfCredit, _p_FIX__BrokerOfCreditTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigTradeDate, _p_FIX__OrigTradeDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeDate, _p_FIX__TradeDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DatedDate, _p_FIX__DatedDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegDatedDate, _p_FIX__LegDatedDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CrossID, _p_FIX__CrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigCrossID, _p_FIX__OrigCrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__HostCrossID, _p_FIX__HostCrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollAsgnRefID, _p_FIX__CollAsgnRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityReqID, _p_FIX__SecurityReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OpenCloseSettlFlag, _p_FIX__OpenCloseSettlFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefOrderID, _p_FIX__RefOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryOrderID, _p_FIX__SecondaryOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AffectedSecondaryOrderID, _p_FIX__AffectedSecondaryOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NotAffectedOrderID, _p_FIX__NotAffectedOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderID, _p_FIX__OrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AffectedOrderID, _p_FIX__AffectedOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MailingInst, _p_FIX__MailingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CustOrderHandlingInst, _p_FIX__CustOrderHandlingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskOrderHandlingInst, _p_FIX__DeskOrderHandlingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlSessSubID, _p_FIX__SettlSessSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurvePoint, _p_FIX__LegBenchmarkCurvePointTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurvePoint, _p_FIX__BenchmarkCurvePointTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraTrader, _p_FIX__ContraTraderTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentRef, _p_FIX__PaymentRefTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionID, _p_FIX__TradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionID, _p_FIX__TriggerTradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionID, _p_FIX__UnderlyingTradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Scope, _p_FIX__ScopeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqID, _p_FIX__StreamAsgnReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AsgnReqID, _p_FIX__AsgnReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstID, _p_FIX__SettlInstIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecRefID, _p_FIX__ExecRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardExpDate, _p_FIX__CardExpDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExDate, _p_FIX__ExDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteSetID, _p_FIX__QuoteSetIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctNumber, _p_FIX__CashDistribAgentAcctNumberTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardNumber, _p_FIX__CardNumberTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LastNetworkResponseID, _p_FIX__LastNetworkResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityResponseID, _p_FIX__SecurityResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NetworkResponseID, _p_FIX__NetworkResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplResponseID, _p_FIX__ApplResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LastMkt, _p_FIX__LastMktTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDMkt, _p_FIX__MDMktTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntrySeller, _p_FIX__MDEntrySellerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RedemptionDate, _p_FIX__RedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeOriginationDate, _p_FIX__TradeOriginationDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRedemptionDate, _p_FIX__LegRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRedemptionDate, _p_FIX__UnderlyingRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionDate, _p_FIX__YieldRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeID, _p_FIX__TradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryFirmTradeID, _p_FIX__SecondaryFirmTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FirmTradeID, _p_FIX__FirmTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeID, _p_FIX__SecondaryTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigTradeID, _p_FIX__OrigTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigSecondaryTradeID, _p_FIX__OrigSecondaryTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InvestorCountryOfResidence, _p_FIX__InvestorCountryOfResidenceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CreditRating, _p_FIX__CreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCreditRating, _p_FIX__LegCreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCreditRating, _p_FIX__UnderlyingCreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmRefID, _p_FIX__ConfirmRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryBuyer, _p_FIX__MDEntryBuyerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderSubID, _p_FIX__SenderSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCashType, _p_FIX__UnderlyingCashTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampOrigin, _p_FIX__TrdRegTimestampOriginTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TrdMatchID, _p_FIX__TrdMatchIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmReqID, _p_FIX__ConfirmReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityRuleID, _p_FIX__MaturityRuleIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrikeRuleID, _p_FIX__StrikeRuleIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityID, _p_FIX__TriggerSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityID, _p_FIX__LegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityID, _p_FIX__SecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityID, _p_FIX__RiskSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityID, _p_FIX__UnderlyingSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityID, _p_FIX__UnderlyingLegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityID, _p_FIX__RelationshipRiskSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefCompID, _p_FIX__RefCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderCompID, _p_FIX__SenderCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetCompID, _p_FIX__TargetCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__HopCompID, _p_FIX__HopCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfCompID, _p_FIX__OnBehalfOfCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactPhone, _p_FIX__CashSettlAgentContactPhoneTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, _p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToCompID, _p_FIX__DeliverToCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmID, _p_FIX__ConfirmIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EndDate, _p_FIX__EndDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, _p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCountryOfIssue, _p_FIX__LegCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, _p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeCountryOfIssue, _p_FIX__DerivativeCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, _p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCountryOfIssue, _p_FIX__UnderlyingCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LocaleOfIssue, _p_FIX__LocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegLocaleOfIssue, _p_FIX__LegLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StateOrProvinceOfIssue, _p_FIX__StateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CountryOfIssue, _p_FIX__CountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeLocaleOfIssue, _p_FIX__DerivativeLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, _p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldType, _p_FIX__YieldTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSymbol, _p_FIX__EncodedSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSymbol, _p_FIX__TriggerSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Symbol, _p_FIX__SymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbol, _p_FIX__UnderlyingLegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSymbol, _p_FIX__PegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSymbol, _p_FIX__RiskSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbol, _p_FIX__UnderlyingSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSymbol, _p_FIX__LegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSymbol, _p_FIX__DerivativeSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSymbol, _p_FIX__RelationshipRiskSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AltMDSourceID, _p_FIX__AltMDSourceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrategyParameterValue, _p_FIX__StrategyParameterValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlMethod, _p_FIX__UnderlyingSettlMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, _p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ValuationMethod, _p_FIX__ValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FuturesValuationMethod, _p_FIX__FuturesValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeValuationMethod, _p_FIX__DerivativeValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativePriceQuoteMethod, _p_FIX__DerivativePriceQuoteMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PriceQuoteMethod, _p_FIX__PriceQuoteMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__WaveNo, _p_FIX__WaveNoTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistDtls, _p_FIX__RegistDtlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligMsgID, _p_FIX__SettlObligMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewPassword, _p_FIX__NewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Password, _p_FIX__PasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncryptedPassword, _p_FIX__EncryptedPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StringField, 0, 0, 0},  {&_swigt__p_FIX__MessageEncoding, _p_FIX__MessageEncodingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIQty, _p_FIX__IOIQtyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIOIQty, _p_FIX__LegIOIQtyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefMsgType, _p_FIX__RefMsgTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MsgType, _p_FIX__MsgTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDesc, _p_FIX__EncodedMktSegmDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettleOnOpenFlag, _p_FIX__SettleOnOpenFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, _p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollReqID, _p_FIX__CollReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXML, _p_FIX__DerivativeSecurityXMLTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityXML, _p_FIX__SecurityXMLTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetStrategyParameters, _p_FIX__TargetStrategyParametersTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityGroup, _p_FIX__RiskSecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityGroup, _p_FIX__RelationshipRiskSecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityGroup, _p_FIX__SecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSeniority, _p_FIX__UnderlyingSeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSeniority, _p_FIX__RiskSeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSeniority, _p_FIX__RelationshipRiskSeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Seniority, _p_FIX__SeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StartDate, _p_FIX__StartDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardStartDate, _p_FIX__CardStartDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefSubID, _p_FIX__RefSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSubID, _p_FIX__OnBehalfOfSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingBusinessDate, _p_FIX__ClearingBusinessDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MatchAlgorithm, _p_FIX__MatchAlgorithmTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListID, _p_FIX__ListIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListID, _p_FIX__SecurityListIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribPayRef, _p_FIX__CashDistribPayRefTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegExecInst, _p_FIX__LegExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedListExecInst, _p_FIX__EncodedListExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecInst, _p_FIX__ExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListExecInst, _p_FIX__ListExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryClOrdID, _p_FIX__SecondaryClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClOrdID, _p_FIX__ClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigClOrdID, _p_FIX__OrigClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NotAffOrigClOrdID, _p_FIX__NotAffOrigClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvRefID, _p_FIX__AdvRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__URLLink, _p_FIX__URLLinkTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideReasonCd, _p_FIX__SideReasonCdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStipType, _p_FIX__UnderlyingStipTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentRemitterID, _p_FIX__PaymentRemitterIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskCFICode, _p_FIX__RelationshipRiskCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskCFICode, _p_FIX__RiskCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCFICode, _p_FIX__LegCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeCFICode, _p_FIX__DerivativeCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCFICode, _p_FIX__UnderlyingCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CFICode, _p_FIX__CFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegCFICode, _p_FIX__UnderlyingLegCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplReportID, _p_FIX__ApplReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideTradeReportID, _p_FIX__SideTradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocReportID, _p_FIX__AllocReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeReportID, _p_FIX__TradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegReportID, _p_FIX__LegReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketReportID, _p_FIX__MarketReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MassActionReportID, _p_FIX__MassActionReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RoutingID, _p_FIX__RoutingIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportID, _p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyDetailsListReportID, _p_FIX__PartyDetailsListReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExchangeSpecialInstructions, _p_FIX__ExchangeSpecialInstructionsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderRestrictions, _p_FIX__OrderRestrictionsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TimeUnit, _p_FIX__TimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegTimeUnit, _p_FIX__LegTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeTimeUnit, _p_FIX__DerivativeTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTimeUnit, _p_FIX__UnderlyingTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecBroker, _p_FIX__ExecBrokerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraBroker, _p_FIX__ContraBrokerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewsID, _p_FIX__NewsIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ParentMktSegmID, _p_FIX__ParentMktSegmIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Subject, _p_FIX__SubjectTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSubject, _p_FIX__EncodedSubjectTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStipValue, _p_FIX__UnderlyingStipValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, _p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityXMLSchema, _p_FIX__SecurityXMLSchemaTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEventText, _p_FIX__DerivativeEventTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EventText, _p_FIX__EventTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionDesc, _p_FIX__TradingSessionDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocID, _p_FIX__AllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIndividualAllocID, _p_FIX__LegIndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocID, _p_FIX__LegAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryIndividualAllocID, _p_FIX__SecondaryIndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefAllocID, _p_FIX__RefAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IndividualAllocID, _p_FIX__IndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryAllocID, _p_FIX__SecondaryAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardIssNum, _p_FIX__CardIssNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityType, _p_FIX__DerivativeSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityType, _p_FIX__LegSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentCode, _p_FIX__CashDistribAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityType, _p_FIX__RiskSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityType, _p_FIX__SecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityType, _p_FIX__UnderlyingSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentCode, _p_FIX__SecuritySettlAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentCode, _p_FIX__CashSettlAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityType, _p_FIX__RelationshipRiskSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ReceivedDeptID, _p_FIX__ReceivedDeptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteMsgID, _p_FIX__QuoteMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCPProgram, _p_FIX__UnderlyingCPProgramTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToSubID, _p_FIX__DeliverToSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RejectText, _p_FIX__RejectTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIShares, _p_FIX__IOISharesTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeIssueDate, _p_FIX__DerivativeIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIssueDate, _p_FIX__UnderlyingIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IssueDate, _p_FIX__IssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIssueDate, _p_FIX__LegIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteID, _p_FIX__QuoteIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListDesc, _p_FIX__SecurityListDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClOrdLinkID, _p_FIX__ClOrdLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDesc, _p_FIX__EncodedSecurityListDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TierCode, _p_FIX__TierCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeLinkID, _p_FIX__TradeLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocLinkID, _p_FIX__AllocLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedHeadline, _p_FIX__EncodedHeadlineTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Headline, _p_FIX__HeadlineTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistEmail, _p_FIX__RegistEmailTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityAltIDSource, _p_FIX__RiskSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityIDSource, _p_FIX__RelationshipRiskSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MessageEventSource, _p_FIX__MessageEventSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeInputSource, _p_FIX__TradeInputSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityIDSource, _p_FIX__LegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IDSource, _p_FIX__IDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, _p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityIDSource, _p_FIX__RiskSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityIDSource, _p_FIX__DerivativeSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityIDSource, _p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, _p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityIDSource, _p_FIX__SecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContAmtCurr, _p_FIX__ContAmtCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, _p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityAltIDSource, _p_FIX__SecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIDSource, _p_FIX__UnderlyingIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityAltIDSource, _p_FIX__RelationshipRiskSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityAltIDSource, _p_FIX__LegSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityIDSource, _p_FIX__TriggerSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityIDSource, _p_FIX__PegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InputSource, _p_FIX__InputSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityIDSource, _p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocAcctIDSource, _p_FIX__LegAllocAcctIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, _p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, _p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityDay, _p_FIX__MaturityDayTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosType, _p_FIX__PosTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDay, _p_FIX__UnderlyingMaturityDayTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideComplianceID, _p_FIX__SideComplianceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ComplianceID, _p_FIX__ComplianceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListName, _p_FIX__ListNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingFirm, _p_FIX__ClearingFirmTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldCalcDate, _p_FIX__YieldCalcDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OpenCloseSettleFlag, _p_FIX__OpenCloseSettleFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListRefID, _p_FIX__SecurityListRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstRefID, _p_FIX__SettlInstRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BusinessRejectRefID, _p_FIX__BusinessRejectRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistRefID, _p_FIX__RegistRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocReportRefID, _p_FIX__AllocReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeReportRefID, _p_FIX__TradeReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosMaintRptRefID, _p_FIX__PosMaintRptRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportRefID, _p_FIX__SecondaryTradeReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistAcctType, _p_FIX__RegistAcctTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideFillStationCd, _p_FIX__SideFillStationCdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested2PartySubID, _p_FIX__Nested2PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedPartySubID, _p_FIX__NestedPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContextPartySubID, _p_FIX__ContextPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedContextPartySubID, _p_FIX__RelatedContextPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatedPartySubID, _p_FIX__RelatedPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteEntryID, _p_FIX__QuoteEntryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RootPartySubID, _p_FIX__RootPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryID, _p_FIX__MDEntryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartySubID, _p_FIX__PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlPartySubID, _p_FIX__SettlPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, _p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested4PartySubID, _p_FIX__Nested4PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested3PartySubID, _p_FIX__Nested3PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, _p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubID, _p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__XmlData, _p_FIX__XmlDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDStreamID, _p_FIX__MDStreamIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstReqID, _p_FIX__SettlInstReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketReqID, _p_FIX__MarketReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollRptID, _p_FIX__CollRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TestReqID, _p_FIX__TestReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIRefID, _p_FIX__IOIRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, _p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctNum, _p_FIX__CashSettlAgentAcctNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LanguageCode, _p_FIX__LanguageCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSymbolSfx, _p_FIX__RiskSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, _p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SymbolSfx, _p_FIX__SymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, _p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionSubID, _p_FIX__TradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionSubID, _p_FIX__TriggerTradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSymbolSfx, _p_FIX__DerivativeSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbolSfx, _p_FIX__UnderlyingSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSymbolSfx, _p_FIX__LegSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSymbolSfx, _p_FIX__RelationshipRiskSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocAccount, _p_FIX__AllocAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocAccount, _p_FIX__LegAllocAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingAccount, _p_FIX__ClearingAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Account, _p_FIX__AccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedIssuer, _p_FIX__EncodedIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuer, _p_FIX__DerivativeEncodedIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Issuer, _p_FIX__IssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuer, _p_FIX__EncodedLegIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIssuer, _p_FIX__UnderlyingIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeIssuer, _p_FIX__DerivativeIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuer, _p_FIX__EncodedUnderlyingIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIssuer, _p_FIX__LegIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BidDescriptor, _p_FIX__BidDescriptorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, _p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySubType, _p_FIX__SecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecuritySubType, _p_FIX__RelationshipRiskSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecuritySubType, _p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecuritySubType, _p_FIX__LegSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecuritySubType, _p_FIX__RiskSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecuritySubType, _p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TimeBracket, _p_FIX__TimeBracketTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosAmtType, _p_FIX__PosAmtTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvTransType, _p_FIX__AdvTransTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDepositoryCode, _p_FIX__SettlDepositoryCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskWarningLevelName, _p_FIX__RiskWarningLevelNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskWarningLevelName, _p_FIX__RelationshipRiskWarningLevelNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CPRegType, _p_FIX__CPRegTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegPool, _p_FIX__LegPoolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCPRegType, _p_FIX__UnderlyingCPRegTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RawData, _p_FIX__RawDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketID, _p_FIX__MarketIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDate2, _p_FIX__SettlDate2To_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DlvyInst, _p_FIX__DlvyInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskID, _p_FIX__DeskIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewsRefID, _p_FIX__NewsRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribCurr, _p_FIX__CashDistribCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketSegmentID, _p_FIX__MarketSegmentIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStipulationValue, _p_FIX__LegStipulationValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementID, _p_FIX__AgreementIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StipulationValue, _p_FIX__StipulationValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityDate, _p_FIX__MaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityDate, _p_FIX__UnderlyingLegMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuantityDate, _p_FIX__QuantityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityDate, _p_FIX__LegMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDate, _p_FIX__UnderlyingMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MassStatusReqID, _p_FIX__MassStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradSesReqID, _p_FIX__TradSesReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosReqID, _p_FIX__PosReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityStatusReqID, _p_FIX__SecurityStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StandInstDbName, _p_FIX__StandInstDbNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityTime, _p_FIX__LegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityTime, _p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskMaturityTime, _p_FIX__RelationshipRiskMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskMaturityTime, _p_FIX__RiskMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityTime, _p_FIX__UnderlyingMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityTime, _p_FIX__MaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Designation, _p_FIX__DesignationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExDestination, _p_FIX__ExDestinationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ResponseDestination, _p_FIX__ResponseDestinationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegInterestAccrualDate, _p_FIX__LegInterestAccrualDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InterestAccrualDate, _p_FIX__InterestAccrualDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardIssNo, _p_FIX__CardIssNoTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveName, _p_FIX__LegBenchmarkCurveNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveName, _p_FIX__BenchmarkCurveNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEventDate, _p_FIX__DerivativeEventDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CouponPaymentDate, _p_FIX__CouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementDate, _p_FIX__UnderlyingSettlementDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, _p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentDate, _p_FIX__PaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EventDate, _p_FIX__EventDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementDate, _p_FIX__AgreementDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCouponPaymentDate, _p_FIX__LegCouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MatchType, _p_FIX__MatchTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CorporateAction, _p_FIX__CorporateActionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EmailThreadID, _p_FIX__EmailThreadIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlLocation, _p_FIX__SettlLocationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MiscFeeCurr, _p_FIX__MiscFeeCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIID, _p_FIX__IOIIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlType, _p_FIX__SettlTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskInstrumentSettlType, _p_FIX__RelationshipRiskInstrumentSettlTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistDetls, _p_FIX__RegistDetlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskInstrumentSettlType, _p_FIX__RiskInstrumentSettlTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvId, _p_FIX__AdvIdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TZTransactTime, _p_FIX__TZTransactTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraLegRefID, _p_FIX__ContraLegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeLegRefID, _p_FIX__TradeLegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRefID, _p_FIX__LegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligRefID, _p_FIX__SettlObligRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContractSettlMonth, _p_FIX__ContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegContractSettlMonth, _p_FIX__LegContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BookingRefID, _p_FIX__BookingRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeContractSettlMonth, _p_FIX__DerivativeContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecureData, _p_FIX__SecureDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribValue, _p_FIX__NestedInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribValue, _p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrAttribValue, _p_FIX__InstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityExchange, _p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskSecurityExchange, _p_FIX__RiskSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskSecurityExchange, _p_FIX__RelationshipRiskSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityExchange, _p_FIX__LegSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityExchange, _p_FIX__SecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, _p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityExchange, _p_FIX__DerivativeSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskRestructuringType, _p_FIX__RiskRestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskRestructuringType, _p_FIX__RelationshipRiskRestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRestructuringType, _p_FIX__UnderlyingRestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DateOfBirth, _p_FIX__DateOfBirthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExpireDate, _p_FIX__ExpireDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BasisFeatureDate, _p_FIX__BasisFeatureDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollRespID, _p_FIX__CollRespIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RptSys, _p_FIX__RptSysTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteRespID, _p_FIX__QuoteRespIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskProductComplex, _p_FIX__RiskProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskProductComplex, _p_FIX__RelationshipRiskProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ProductComplex, _p_FIX__ProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeProductComplex, _p_FIX__DerivativeProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligID, _p_FIX__SettlObligIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistID, _p_FIX__RegistIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MiscFeeType, _p_FIX__MiscFeeTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityMonthYear, _p_FIX__LegMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StartMaturityMonthYear, _p_FIX__StartMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYear, _p_FIX__MaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityMonthYear, _p_FIX__DerivativeMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, _p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EndMaturityMonthYear, _p_FIX__EndMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, _p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelationshipRiskMaturityMonthYear, _p_FIX__RelationshipRiskMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RiskMaturityMonthYear, _p_FIX__RiskMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigPosReqRefID, _p_FIX__OrigPosReqRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosMaintRptID, _p_FIX__PosMaintRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContIntRptID, _p_FIX__ContIntRptIDTo_p_FIX__StringField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Subject[] = {  {&_swigt__p_FIX__Subject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SubscriptionRequestType[] = {  {&_swigt__p_FIX__SubscriptionRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SwapPoints[] = {  {&_swigt__p_FIX__SwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Symbol[] = {  {&_swigt__p_FIX__Symbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SymbolSfx[] = {  {&_swigt__p_FIX__SymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SynchronizedApplication[] = {  {&_swigt__p_FIX__SynchronizedApplication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TYPE__Type[] = {  {&_swigt__p_FIX__TYPE__Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTIMEONLY[] = {  {&_swigt__p_FIX__TZTIMEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTIMESTAMP[] = {  {&_swigt__p_FIX__TZTIMESTAMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTransactTime[] = {  {&_swigt__p_FIX__TZTransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TagNotDefinedForMessage[] = {  {&_swigt__p_FIX__TagNotDefinedForMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TagOutOfOrder[] = {  {&_swigt__p_FIX__TagOutOfOrder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetCompID[] = {  {&_swigt__p_FIX__TargetCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetLocationID[] = {  {&_swigt__p_FIX__TargetLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyID[] = {  {&_swigt__p_FIX__TargetPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyIDSource[] = {  {&_swigt__p_FIX__TargetPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyRole[] = {  {&_swigt__p_FIX__TargetPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategy[] = {  {&_swigt__p_FIX__TargetStrategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategyParameters[] = {  {&_swigt__p_FIX__TargetStrategyParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategyPerformance[] = {  {&_swigt__p_FIX__TargetStrategyPerformance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetSubID[] = {  {&_swigt__p_FIX__TargetSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TaxAdvantageType[] = {  {&_swigt__p_FIX__TaxAdvantageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TerminationType[] = {  {&_swigt__p_FIX__TerminationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TestMessageIndicator[] = {  {&_swigt__p_FIX__TestMessageIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TestReqID[] = {  {&_swigt__p_FIX__TestReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Text[] = {  {&_swigt__p_FIX__Text, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ThresholdAmount[] = {  {&_swigt__p_FIX__ThresholdAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickDirection[] = {  {&_swigt__p_FIX__TickDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickIncrement[] = {  {&_swigt__p_FIX__TickIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickRuleType[] = {  {&_swigt__p_FIX__TickRuleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TierCode[] = {  {&_swigt__p_FIX__TierCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeBracket[] = {  {&_swigt__p_FIX__TimeBracket, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeInForce[] = {  {&_swigt__p_FIX__TimeInForce, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeToExpiration[] = {  {&_swigt__p_FIX__TimeToExpiration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeUnit[] = {  {&_swigt__p_FIX__TimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoAccQuotes[] = {  {&_swigt__p_FIX__TotNoAccQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoAllocs[] = {  {&_swigt__p_FIX__TotNoAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoCxldQuotes[] = {  {&_swigt__p_FIX__TotNoCxldQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoFills[] = {  {&_swigt__p_FIX__TotNoFills, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoOrders[] = {  {&_swigt__p_FIX__TotNoOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoPartyList[] = {  {&_swigt__p_FIX__TotNoPartyList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoQuoteEntries[] = {  {&_swigt__p_FIX__TotNoQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoRejQuotes[] = {  {&_swigt__p_FIX__TotNoRejQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoRelatedSym[] = {  {&_swigt__p_FIX__TotNoRelatedSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoSecurityTypes[] = {  {&_swigt__p_FIX__TotNoSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoStrikes[] = {  {&_swigt__p_FIX__TotNoStrikes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumAssignmentReports[] = {  {&_swigt__p_FIX__TotNumAssignmentReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumReports[] = {  {&_swigt__p_FIX__TotNumReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumTradeReports[] = {  {&_swigt__p_FIX__TotNumTradeReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotQuoteEntries[] = {  {&_swigt__p_FIX__TotQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalAccruedInterestAmt[] = {  {&_swigt__p_FIX__TotalAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalAffectedOrders[] = {  {&_swigt__p_FIX__TotalAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNetValue[] = {  {&_swigt__p_FIX__TotalNetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumPosReports[] = {  {&_swigt__p_FIX__TotalNumPosReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumSecurities[] = {  {&_swigt__p_FIX__TotalNumSecurities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumSecurityTypes[] = {  {&_swigt__p_FIX__TotalNumSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalTakedown[] = {  {&_swigt__p_FIX__TotalTakedown, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTraded[] = {  {&_swigt__p_FIX__TotalVolumeTraded, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTradedDate[] = {  {&_swigt__p_FIX__TotalVolumeTradedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTradedTime[] = {  {&_swigt__p_FIX__TotalVolumeTradedTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesCloseTime[] = {  {&_swigt__p_FIX__TradSesCloseTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesEndTime[] = {  {&_swigt__p_FIX__TradSesEndTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesEvent[] = {  {&_swigt__p_FIX__TradSesEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesMethod[] = {  {&_swigt__p_FIX__TradSesMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesMode[] = {  {&_swigt__p_FIX__TradSesMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesOpenTime[] = {  {&_swigt__p_FIX__TradSesOpenTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesPreCloseTime[] = {  {&_swigt__p_FIX__TradSesPreCloseTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesReqID[] = {  {&_swigt__p_FIX__TradSesReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStartTime[] = {  {&_swigt__p_FIX__TradSesStartTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStatus[] = {  {&_swigt__p_FIX__TradSesStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStatusRejReason[] = {  {&_swigt__p_FIX__TradSesStatusRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesUpdateAction[] = {  {&_swigt__p_FIX__TradSesUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeAllocIndicator[] = {  {&_swigt__p_FIX__TradeAllocIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeCondition[] = {  {&_swigt__p_FIX__TradeCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeDate[] = {  {&_swigt__p_FIX__TradeDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeHandlingInstr[] = {  {&_swigt__p_FIX__TradeHandlingInstr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeID[] = {  {&_swigt__p_FIX__TradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeInputDevice[] = {  {&_swigt__p_FIX__TradeInputDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeInputSource[] = {  {&_swigt__p_FIX__TradeInputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeLegRefID[] = {  {&_swigt__p_FIX__TradeLegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeLinkID[] = {  {&_swigt__p_FIX__TradeLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeOriginationDate[] = {  {&_swigt__p_FIX__TradeOriginationDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradePublishIndicator[] = {  {&_swigt__p_FIX__TradePublishIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportID[] = {  {&_swigt__p_FIX__TradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportRefID[] = {  {&_swigt__p_FIX__TradeReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportRejectReason[] = {  {&_swigt__p_FIX__TradeReportRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportTransType[] = {  {&_swigt__p_FIX__TradeReportTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportType[] = {  {&_swigt__p_FIX__TradeReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestID[] = {  {&_swigt__p_FIX__TradeRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestResult[] = {  {&_swigt__p_FIX__TradeRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestStatus[] = {  {&_swigt__p_FIX__TradeRequestStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestType[] = {  {&_swigt__p_FIX__TradeRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeType[] = {  {&_swigt__p_FIX__TradeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeVolume[] = {  {&_swigt__p_FIX__TradeVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradedFlatSwitch[] = {  {&_swigt__p_FIX__TradedFlatSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingCurrency[] = {  {&_swigt__p_FIX__TradingCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingReferencePrice[] = {  {&_swigt__p_FIX__TradingReferencePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionDesc[] = {  {&_swigt__p_FIX__TradingSessionDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionID[] = {  {&_swigt__p_FIX__TradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionSubID[] = {  {&_swigt__p_FIX__TradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransBkdTime[] = {  {&_swigt__p_FIX__TransBkdTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransactTime[] = {  {&_swigt__p_FIX__TransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransferReason[] = {  {&_swigt__p_FIX__TransferReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdMatchID[] = {  {&_swigt__p_FIX__TrdMatchID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestamp[] = {  {&_swigt__p_FIX__TrdRegTimestamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestampOrigin[] = {  {&_swigt__p_FIX__TrdRegTimestampOrigin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestampType[] = {  {&_swigt__p_FIX__TrdRegTimestampType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRepIndicator[] = {  {&_swigt__p_FIX__TrdRepIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRepPartyRole[] = {  {&_swigt__p_FIX__TrdRepPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRptStatus[] = {  {&_swigt__p_FIX__TrdRptStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdSubType[] = {  {&_swigt__p_FIX__TrdSubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdType[] = {  {&_swigt__p_FIX__TrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerAction[] = {  {&_swigt__p_FIX__TriggerAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerNewPrice[] = {  {&_swigt__p_FIX__TriggerNewPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerNewQty[] = {  {&_swigt__p_FIX__TriggerNewQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerOrderType[] = {  {&_swigt__p_FIX__TriggerOrderType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPrice[] = {  {&_swigt__p_FIX__TriggerPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceDirection[] = {  {&_swigt__p_FIX__TriggerPriceDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceType[] = {  {&_swigt__p_FIX__TriggerPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceTypeScope[] = {  {&_swigt__p_FIX__TriggerPriceTypeScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityDesc[] = {  {&_swigt__p_FIX__TriggerSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityID[] = {  {&_swigt__p_FIX__TriggerSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityIDSource[] = {  {&_swigt__p_FIX__TriggerSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSymbol[] = {  {&_swigt__p_FIX__TriggerSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerTradingSessionID[] = {  {&_swigt__p_FIX__TriggerTradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerTradingSessionSubID[] = {  {&_swigt__p_FIX__TriggerTradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerType[] = {  {&_swigt__p_FIX__TriggerType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__URLLink[] = {  {&_swigt__p_FIX__URLLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCDATEONLY[] = {  {&_swigt__p_FIX__UTCDATEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCTIMEONLY[] = {  {&_swigt__p_FIX__UTCTIMEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCTIMESTAMP[] = {  {&_swigt__p_FIX__UTCTIMESTAMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAdjustedQuantity[] = {  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAllocationPercent[] = {  {&_swigt__p_FIX__UnderlyingAllocationPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAttachmentPoint[] = {  {&_swigt__p_FIX__UnderlyingAttachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCFICode[] = {  {&_swigt__p_FIX__UnderlyingCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCPProgram[] = {  {&_swigt__p_FIX__UnderlyingCPProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCPRegType[] = {  {&_swigt__p_FIX__UnderlyingCPRegType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCapValue[] = {  {&_swigt__p_FIX__UnderlyingCapValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCashAmount[] = {  {&_swigt__p_FIX__UnderlyingCashAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCashType[] = {  {&_swigt__p_FIX__UnderlyingCashType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCollectAmount[] = {  {&_swigt__p_FIX__UnderlyingCollectAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingContractMultiplier[] = {  {&_swigt__p_FIX__UnderlyingContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingContractMultiplierUnit[] = {  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCountryOfIssue[] = {  {&_swigt__p_FIX__UnderlyingCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCouponPaymentDate[] = {  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCouponRate[] = {  {&_swigt__p_FIX__UnderlyingCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCreditRating[] = {  {&_swigt__p_FIX__UnderlyingCreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCurrency[] = {  {&_swigt__p_FIX__UnderlyingCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCurrentValue[] = {  {&_swigt__p_FIX__UnderlyingCurrentValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDeliveryAmount[] = {  {&_swigt__p_FIX__UnderlyingDeliveryAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDetachmentPoint[] = {  {&_swigt__p_FIX__UnderlyingDetachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDirtyPrice[] = {  {&_swigt__p_FIX__UnderlyingDirtyPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingEndPrice[] = {  {&_swigt__p_FIX__UnderlyingEndPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingEndValue[] = {  {&_swigt__p_FIX__UnderlyingEndValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingExerciseStyle[] = {  {&_swigt__p_FIX__UnderlyingExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFXRate[] = {  {&_swigt__p_FIX__UnderlyingFXRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFXRateCalc[] = {  {&_swigt__p_FIX__UnderlyingFXRateCalc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFactor[] = {  {&_swigt__p_FIX__UnderlyingFactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFlowScheduleType[] = {  {&_swigt__p_FIX__UnderlyingFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIDSource[] = {  {&_swigt__p_FIX__UnderlyingIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrRegistry[] = {  {&_swigt__p_FIX__UnderlyingInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyID[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyRole[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartySubID[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIssueDate[] = {  {&_swigt__p_FIX__UnderlyingIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIssuer[] = {  {&_swigt__p_FIX__UnderlyingIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLastPx[] = {  {&_swigt__p_FIX__UnderlyingLastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLastQty[] = {  {&_swigt__p_FIX__UnderlyingLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegCFICode[] = {  {&_swigt__p_FIX__UnderlyingLegCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityDate[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityMonthYear[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityTime[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegOptAttribute[] = {  {&_swigt__p_FIX__UnderlyingLegOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegPutOrCall[] = {  {&_swigt__p_FIX__UnderlyingLegPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityAltID[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityAltIDSource[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityDesc[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityExchange[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityID[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityIDSource[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecuritySubType[] = {  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityType[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegStrikePrice[] = {  {&_swigt__p_FIX__UnderlyingLegStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSymbol[] = {  {&_swigt__p_FIX__UnderlyingLegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSymbolSfx[] = {  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLocaleOfIssue[] = {  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityDate[] = {  {&_swigt__p_FIX__UnderlyingMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityDay[] = {  {&_swigt__p_FIX__UnderlyingMaturityDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityMonthYear[] = {  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityTime[] = {  {&_swigt__p_FIX__UnderlyingMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingOptAttribute[] = {  {&_swigt__p_FIX__UnderlyingOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPayAmount[] = {  {&_swigt__p_FIX__UnderlyingPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceDeterminationMethod[] = {  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceUnitOfMeasure[] = {  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingProduct[] = {  {&_swigt__p_FIX__UnderlyingProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPutOrCall[] = {  {&_swigt__p_FIX__UnderlyingPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPx[] = {  {&_swigt__p_FIX__UnderlyingPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingQty[] = {  {&_swigt__p_FIX__UnderlyingQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRedemptionDate[] = {  {&_swigt__p_FIX__UnderlyingRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepoCollateralSecurityType[] = {  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepurchaseRate[] = {  {&_swigt__p_FIX__UnderlyingRepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepurchaseTerm[] = {  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRestructuringType[] = {  {&_swigt__p_FIX__UnderlyingRestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityAltID[] = {  {&_swigt__p_FIX__UnderlyingSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityAltIDSource[] = {  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityDesc[] = {  {&_swigt__p_FIX__UnderlyingSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityExchange[] = {  {&_swigt__p_FIX__UnderlyingSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityID[] = {  {&_swigt__p_FIX__UnderlyingSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityIDSource[] = {  {&_swigt__p_FIX__UnderlyingSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecuritySubType[] = {  {&_swigt__p_FIX__UnderlyingSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityType[] = {  {&_swigt__p_FIX__UnderlyingSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSeniority[] = {  {&_swigt__p_FIX__UnderlyingSeniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlMethod[] = {  {&_swigt__p_FIX__UnderlyingSettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlPrice[] = {  {&_swigt__p_FIX__UnderlyingSettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlPriceType[] = {  {&_swigt__p_FIX__UnderlyingSettlPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementDate[] = {  {&_swigt__p_FIX__UnderlyingSettlementDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementStatus[] = {  {&_swigt__p_FIX__UnderlyingSettlementStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementType[] = {  {&_swigt__p_FIX__UnderlyingSettlementType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStartValue[] = {  {&_swigt__p_FIX__UnderlyingStartValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStipType[] = {  {&_swigt__p_FIX__UnderlyingStipType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStipValue[] = {  {&_swigt__p_FIX__UnderlyingStipValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStrikeCurrency[] = {  {&_swigt__p_FIX__UnderlyingStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStrikePrice[] = {  {&_swigt__p_FIX__UnderlyingStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSymbol[] = {  {&_swigt__p_FIX__UnderlyingSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSymbolSfx[] = {  {&_swigt__p_FIX__UnderlyingSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTimeUnit[] = {  {&_swigt__p_FIX__UnderlyingTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTradingSessionID[] = {  {&_swigt__p_FIX__UnderlyingTradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTradingSessionSubID[] = {  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingUnitOfMeasure[] = {  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingUnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyID[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyRole[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartySubID[] = {  {&_swigt__p_FIX__UndlyInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnitOfMeasure[] = {  {&_swigt__p_FIX__UnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsolicitedIndicator[] = {  {&_swigt__p_FIX__UnsolicitedIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsupportedMessageType[] = {  {&_swigt__p_FIX__UnsupportedMessageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsupportedVersion[] = {  {&_swigt__p_FIX__UnsupportedVersion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Urgency[] = {  {&_swigt__p_FIX__Urgency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserRequestID[] = {  {&_swigt__p_FIX__UserRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserRequestType[] = {  {&_swigt__p_FIX__UserRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserStatus[] = {  {&_swigt__p_FIX__UserStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserStatusText[] = {  {&_swigt__p_FIX__UserStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Username[] = {  {&_swigt__p_FIX__Username, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcDateField[] = {  {&_swigt__p_FIX__UtcDateField, 0, 0, 0},  {&_swigt__p_FIX__MDEntryDate, _p_FIX__MDEntryDateTo_p_FIX__UtcDateField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedDate, _p_FIX__TotalVolumeTradedDateTo_p_FIX__UtcDateField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcTimeOnlyField[] = {  {&_swigt__p_FIX__UtcTimeOnlyField, 0, 0, 0},  {&_swigt__p_FIX__MDEntryTime, _p_FIX__MDEntryTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__ComplexEventStartTime, _p_FIX__ComplexEventStartTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedTime, _p_FIX__TotalVolumeTradedTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__ComplexEventEndTime, _p_FIX__ComplexEventEndTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcTimeStampField[] = {  {&_swigt__p_FIX__TradSesEndTime, _p_FIX__TradSesEndTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigTime, _p_FIX__OrigTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__DerivativeEventTime, _p_FIX__DerivativeEventTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__EventTime, _p_FIX__EventTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigOrdModTime, _p_FIX__OrigOrdModTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesOpenTime, _p_FIX__TradSesOpenTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__UtcTimeStampField, 0, 0, 0},  {&_swigt__p_FIX__ExecValuationPoint, _p_FIX__ExecValuationPointTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ComplexEventStartDate, _p_FIX__ComplexEventStartDateTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SideTimeInForce, _p_FIX__SideTimeInForceTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ExpireTime, _p_FIX__ExpireTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TransBkdTime, _p_FIX__TransBkdTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesPreCloseTime, _p_FIX__TradSesPreCloseTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesCloseTime, _p_FIX__TradSesCloseTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesStartTime, _p_FIX__TradSesStartTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__StrikeTime, _p_FIX__StrikeTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__LastUpdateTime, _p_FIX__LastUpdateTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__QuoteSetValidUntilTime, _p_FIX__QuoteSetValidUntilTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ValidUntilTime, _p_FIX__ValidUntilTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__RelSymTransactTime, _p_FIX__RelSymTransactTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestamp, _p_FIX__SideTrdRegTimestampTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ContraTradeTime, _p_FIX__ContraTradeTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TransactTime, _p_FIX__TransactTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestamp, _p_FIX__TrdRegTimestampTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigSendingTime, _p_FIX__OrigSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ComplexEventEndDate, _p_FIX__ComplexEventEndDateTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__HopSendingTime, _p_FIX__HopSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSendingTime, _p_FIX__OnBehalfOfSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SendingTime, _p_FIX__SendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__EffectiveTime, _p_FIX__EffectiveTimeTo_p_FIX__UtcTimeStampField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValidUntilTime[] = {  {&_swigt__p_FIX__ValidUntilTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValuationMethod[] = {  {&_swigt__p_FIX__ValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValueOfFutures[] = {  {&_swigt__p_FIX__ValueOfFutures, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__VenueType[] = {  {&_swigt__p_FIX__VenueType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Volatility[] = {  {&_swigt__p_FIX__Volatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WaveNo[] = {  {&_swigt__p_FIX__WaveNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WorkingIndicator[] = {  {&_swigt__p_FIX__WorkingIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WtAverageLiquidity[] = {  {&_swigt__p_FIX__WtAverageLiquidity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XMLDATA[] = {  {&_swigt__p_FIX__XMLDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XmlData[] = {  {&_swigt__p_FIX__XmlData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XmlDataLen[] = {  {&_swigt__p_FIX__XmlDataLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Yield[] = {  {&_swigt__p_FIX__Yield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldCalcDate[] = {  {&_swigt__p_FIX__YieldCalcDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionDate[] = {  {&_swigt__p_FIX__YieldRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionPrice[] = {  {&_swigt__p_FIX__YieldRedemptionPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionPriceType[] = {  {&_swigt__p_FIX__YieldRedemptionPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldType[] = {  {&_swigt__p_FIX__YieldType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fields[] = {  {&_swigt__p_Fields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Group[] = {  {&_swigt__p_Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Groups[] = {  {&_swigt__p_Groups, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntArray[] = {  {&_swigt__p_IntArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntField[] = {  {&_swigt__p_IntField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Log[] = {  {&_swigt__p_Log, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogFactory[] = {  {&_swigt__p_LogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageStore[] = {  {&_swigt__p_MessageStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageStoreFactory[] = {  {&_swigt__p_MessageStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MsgType[] = {  {&_swigt__p_MsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mutex[] = {  {&_swigt__p_Mutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Responder[] = {  {&_swigt__p_Responder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SessionID[] = {  {&_swigt__p_SessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StringField[] = {  {&_swigt__p_StringField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TimeRange[] = {  {&_swigt__p_TimeRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcDate[] = {  {&_swigt__p_UtcDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcDateField[] = {  {&_swigt__p_UtcDateField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcTimeOnly[] = {  {&_swigt__p_UtcTimeOnly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcTimeStamp[] = {  {&_swigt__p_UtcTimeStamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_g_const_iterator[] = {  {&_swigt__p_g_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_g_iterator[] = {  {&_swigt__p_g_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_IntArray, _p_IntArrayTo_p_int, 0, 0},  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_message_order[] = {  {&_swigt__p_message_order, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_FIX__DataDictionary[] = {  {&_swigt__p_p_FIX__DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__istream[] = {  {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setTFIX__SessionID_t[] = {  {&_swigt__p_std__setTFIX__SessionID_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string__size_type[] = {  {&_swigt__p_std__string__size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorTstd__string_t[] = {  {&_swigt__p_std__vectorTstd__string_t, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ApplVerID,
  _swigc__p_Application,
  _swigc__p_BeginString,
  _swigc__p_DOMDocumentPtr,
  _swigc__p_Data,
  _swigc__p_DataDictionary,
  _swigc__p_DataDictionaryProvider,
  _swigc__p_DateTime,
  _swigc__p_Dictionaries,
  _swigc__p_DoubleField,
  _swigc__p_FIX__AMT,
  _swigc__p_FIX__Acceptor,
  _swigc__p_FIX__Account,
  _swigc__p_FIX__AccountType,
  _swigc__p_FIX__AccruedInterestAmt,
  _swigc__p_FIX__AccruedInterestRate,
  _swigc__p_FIX__AcctIDSource,
  _swigc__p_FIX__Adjustment,
  _swigc__p_FIX__AdjustmentType,
  _swigc__p_FIX__AdvId,
  _swigc__p_FIX__AdvRefID,
  _swigc__p_FIX__AdvSide,
  _swigc__p_FIX__AdvTransType,
  _swigc__p_FIX__AffectedOrderID,
  _swigc__p_FIX__AffectedSecondaryOrderID,
  _swigc__p_FIX__AffirmStatus,
  _swigc__p_FIX__AggregatedBook,
  _swigc__p_FIX__AggressorIndicator,
  _swigc__p_FIX__AgreementCurrency,
  _swigc__p_FIX__AgreementDate,
  _swigc__p_FIX__AgreementDesc,
  _swigc__p_FIX__AgreementID,
  _swigc__p_FIX__AllocAccount,
  _swigc__p_FIX__AllocAccountType,
  _swigc__p_FIX__AllocAccruedInterestAmt,
  _swigc__p_FIX__AllocAcctIDSource,
  _swigc__p_FIX__AllocAvgPx,
  _swigc__p_FIX__AllocCancReplaceReason,
  _swigc__p_FIX__AllocClearingFeeIndicator,
  _swigc__p_FIX__AllocCustomerCapacity,
  _swigc__p_FIX__AllocHandlInst,
  _swigc__p_FIX__AllocID,
  _swigc__p_FIX__AllocInterestAtMaturity,
  _swigc__p_FIX__AllocIntermedReqType,
  _swigc__p_FIX__AllocLinkID,
  _swigc__p_FIX__AllocLinkType,
  _swigc__p_FIX__AllocMethod,
  _swigc__p_FIX__AllocNetMoney,
  _swigc__p_FIX__AllocNoOrdersType,
  _swigc__p_FIX__AllocPositionEffect,
  _swigc__p_FIX__AllocPrice,
  _swigc__p_FIX__AllocQty,
  _swigc__p_FIX__AllocRejCode,
  _swigc__p_FIX__AllocReportID,
  _swigc__p_FIX__AllocReportRefID,
  _swigc__p_FIX__AllocReportType,
  _swigc__p_FIX__AllocSettlCurrAmt,
  _swigc__p_FIX__AllocSettlCurrency,
  _swigc__p_FIX__AllocSettlInstType,
  _swigc__p_FIX__AllocShares,
  _swigc__p_FIX__AllocStatus,
  _swigc__p_FIX__AllocText,
  _swigc__p_FIX__AllocTransType,
  _swigc__p_FIX__AllocType,
  _swigc__p_FIX__AllowableOneSidednessCurr,
  _swigc__p_FIX__AllowableOneSidednessPct,
  _swigc__p_FIX__AllowableOneSidednessValue,
  _swigc__p_FIX__AltMDSourceID,
  _swigc__p_FIX__ApplBegSeqNum,
  _swigc__p_FIX__ApplEndSeqNum,
  _swigc__p_FIX__ApplExtID,
  _swigc__p_FIX__ApplID,
  _swigc__p_FIX__ApplLastSeqNum,
  _swigc__p_FIX__ApplNewSeqNum,
  _swigc__p_FIX__ApplQueueAction,
  _swigc__p_FIX__ApplQueueDepth,
  _swigc__p_FIX__ApplQueueMax,
  _swigc__p_FIX__ApplQueueResolution,
  _swigc__p_FIX__ApplReportID,
  _swigc__p_FIX__ApplReportType,
  _swigc__p_FIX__ApplReqID,
  _swigc__p_FIX__ApplReqType,
  _swigc__p_FIX__ApplResendFlag,
  _swigc__p_FIX__ApplResponseError,
  _swigc__p_FIX__ApplResponseID,
  _swigc__p_FIX__ApplResponseType,
  _swigc__p_FIX__ApplSeqNum,
  _swigc__p_FIX__ApplTotalMessageCount,
  _swigc__p_FIX__ApplVerID,
  _swigc__p_FIX__Application,
  _swigc__p_FIX__AsOfIndicator,
  _swigc__p_FIX__AsgnReqID,
  _swigc__p_FIX__AsgnRptID,
  _swigc__p_FIX__AssignmentMethod,
  _swigc__p_FIX__AssignmentUnit,
  _swigc__p_FIX__AttachmentPoint,
  _swigc__p_FIX__AutoAcceptIndicator,
  _swigc__p_FIX__AvgParPx,
  _swigc__p_FIX__AvgPrxPrecision,
  _swigc__p_FIX__AvgPx,
  _swigc__p_FIX__AvgPxIndicator,
  _swigc__p_FIX__AvgPxPrecision,
  _swigc__p_FIX__BOOLEAN,
  _swigc__p_FIX__BasisFeatureDate,
  _swigc__p_FIX__BasisFeaturePrice,
  _swigc__p_FIX__BasisPxType,
  _swigc__p_FIX__BeginSeqNo,
  _swigc__p_FIX__BeginString,
  _swigc__p_FIX__Benchmark,
  _swigc__p_FIX__BenchmarkCurveCurrency,
  _swigc__p_FIX__BenchmarkCurveName,
  _swigc__p_FIX__BenchmarkCurvePoint,
  _swigc__p_FIX__BenchmarkPrice,
  _swigc__p_FIX__BenchmarkPriceType,
  _swigc__p_FIX__BenchmarkSecurityID,
  _swigc__p_FIX__BenchmarkSecurityIDSource,
  _swigc__p_FIX__BidDescriptor,
  _swigc__p_FIX__BidDescriptorType,
  _swigc__p_FIX__BidForwardPoints,
  _swigc__p_FIX__BidForwardPoints2,
  _swigc__p_FIX__BidID,
  _swigc__p_FIX__BidPx,
  _swigc__p_FIX__BidRequestTransType,
  _swigc__p_FIX__BidSize,
  _swigc__p_FIX__BidSpotRate,
  _swigc__p_FIX__BidSwapPoints,
  _swigc__p_FIX__BidTradeType,
  _swigc__p_FIX__BidType,
  _swigc__p_FIX__BidYield,
  _swigc__p_FIX__BodyLength,
  _swigc__p_FIX__BookingRefID,
  _swigc__p_FIX__BookingType,
  _swigc__p_FIX__BookingUnit,
  _swigc__p_FIX__BoolField,
  _swigc__p_FIX__BrokerOfCredit,
  _swigc__p_FIX__BusinessRejectReason,
  _swigc__p_FIX__BusinessRejectRefID,
  _swigc__p_FIX__BuyVolume,
  _swigc__p_FIX__CFICode,
  _swigc__p_FIX__CHAR,
  _swigc__p_FIX__COUNTRY,
  _swigc__p_FIX__CPProgram,
  _swigc__p_FIX__CPRegType,
  _swigc__p_FIX__CURRENCY,
  _swigc__p_FIX__CalculatedCcyLastQty,
  _swigc__p_FIX__CancellationRights,
  _swigc__p_FIX__CapPrice,
  _swigc__p_FIX__CardExpDate,
  _swigc__p_FIX__CardHolderName,
  _swigc__p_FIX__CardIssNo,
  _swigc__p_FIX__CardIssNum,
  _swigc__p_FIX__CardNumber,
  _swigc__p_FIX__CardStartDate,
  _swigc__p_FIX__CashDistribAgentAcctName,
  _swigc__p_FIX__CashDistribAgentAcctNumber,
  _swigc__p_FIX__CashDistribAgentCode,
  _swigc__p_FIX__CashDistribAgentName,
  _swigc__p_FIX__CashDistribCurr,
  _swigc__p_FIX__CashDistribPayRef,
  _swigc__p_FIX__CashMargin,
  _swigc__p_FIX__CashOrderQty,
  _swigc__p_FIX__CashOutstanding,
  _swigc__p_FIX__CashSettlAgentAcctName,
  _swigc__p_FIX__CashSettlAgentAcctNum,
  _swigc__p_FIX__CashSettlAgentCode,
  _swigc__p_FIX__CashSettlAgentContactName,
  _swigc__p_FIX__CashSettlAgentContactPhone,
  _swigc__p_FIX__CashSettlAgentName,
  _swigc__p_FIX__CcyAmt,
  _swigc__p_FIX__CharField,
  _swigc__p_FIX__CheckSum,
  _swigc__p_FIX__CheckSumField,
  _swigc__p_FIX__ClOrdID,
  _swigc__p_FIX__ClOrdLinkID,
  _swigc__p_FIX__ClearingAccount,
  _swigc__p_FIX__ClearingBusinessDate,
  _swigc__p_FIX__ClearingFeeIndicator,
  _swigc__p_FIX__ClearingFirm,
  _swigc__p_FIX__ClearingInstruction,
  _swigc__p_FIX__ClientBidID,
  _swigc__p_FIX__ClientID,
  _swigc__p_FIX__CollAction,
  _swigc__p_FIX__CollApplType,
  _swigc__p_FIX__CollAsgnID,
  _swigc__p_FIX__CollAsgnReason,
  _swigc__p_FIX__CollAsgnRefID,
  _swigc__p_FIX__CollAsgnRejectReason,
  _swigc__p_FIX__CollAsgnRespType,
  _swigc__p_FIX__CollAsgnTransType,
  _swigc__p_FIX__CollInquiryID,
  _swigc__p_FIX__CollInquiryQualifier,
  _swigc__p_FIX__CollInquiryResult,
  _swigc__p_FIX__CollInquiryStatus,
  _swigc__p_FIX__CollReqID,
  _swigc__p_FIX__CollRespID,
  _swigc__p_FIX__CollRptID,
  _swigc__p_FIX__CollStatus,
  _swigc__p_FIX__CommCurrency,
  _swigc__p_FIX__CommType,
  _swigc__p_FIX__Commission,
  _swigc__p_FIX__ComplexEventCondition,
  _swigc__p_FIX__ComplexEventEndDate,
  _swigc__p_FIX__ComplexEventEndTime,
  _swigc__p_FIX__ComplexEventPrice,
  _swigc__p_FIX__ComplexEventPriceBoundaryMethod,
  _swigc__p_FIX__ComplexEventPriceBoundaryPrecision,
  _swigc__p_FIX__ComplexEventPriceTimeType,
  _swigc__p_FIX__ComplexEventStartDate,
  _swigc__p_FIX__ComplexEventStartTime,
  _swigc__p_FIX__ComplexEventType,
  _swigc__p_FIX__ComplexOptPayoutAmount,
  _swigc__p_FIX__ComplianceID,
  _swigc__p_FIX__Concession,
  _swigc__p_FIX__ConfigError,
  _swigc__p_FIX__ConfirmID,
  _swigc__p_FIX__ConfirmRefID,
  _swigc__p_FIX__ConfirmRejReason,
  _swigc__p_FIX__ConfirmReqID,
  _swigc__p_FIX__ConfirmStatus,
  _swigc__p_FIX__ConfirmTransType,
  _swigc__p_FIX__ConfirmType,
  _swigc__p_FIX__ContAmtCurr,
  _swigc__p_FIX__ContAmtType,
  _swigc__p_FIX__ContAmtValue,
  _swigc__p_FIX__ContIntRptID,
  _swigc__p_FIX__ContextPartyID,
  _swigc__p_FIX__ContextPartyIDSource,
  _swigc__p_FIX__ContextPartyRole,
  _swigc__p_FIX__ContextPartySubID,
  _swigc__p_FIX__ContextPartySubIDType,
  _swigc__p_FIX__ContingencyType,
  _swigc__p_FIX__ContraBroker,
  _swigc__p_FIX__ContraLegRefID,
  _swigc__p_FIX__ContraTradeQty,
  _swigc__p_FIX__ContraTradeTime,
  _swigc__p_FIX__ContraTrader,
  _swigc__p_FIX__ContractMultiplier,
  _swigc__p_FIX__ContractMultiplierUnit,
  _swigc__p_FIX__ContractSettlMonth,
  _swigc__p_FIX__ContraryInstructionIndicator,
  _swigc__p_FIX__CopyMsgIndicator,
  _swigc__p_FIX__CorporateAction,
  _swigc__p_FIX__Country,
  _swigc__p_FIX__CountryOfIssue,
  _swigc__p_FIX__CouponPaymentDate,
  _swigc__p_FIX__CouponRate,
  _swigc__p_FIX__CoveredOrUncovered,
  _swigc__p_FIX__CreditRating,
  _swigc__p_FIX__CrossID,
  _swigc__p_FIX__CrossPercent,
  _swigc__p_FIX__CrossPrioritization,
  _swigc__p_FIX__CrossType,
  _swigc__p_FIX__CstmApplVerID,
  _swigc__p_FIX__CumQty,
  _swigc__p_FIX__Currency,
  _swigc__p_FIX__CurrencyRatio,
  _swigc__p_FIX__CustDirectedOrder,
  _swigc__p_FIX__CustOrderCapacity,
  _swigc__p_FIX__CustOrderHandlingInst,
  _swigc__p_FIX__CustomerOrFirm,
  _swigc__p_FIX__CxlQty,
  _swigc__p_FIX__CxlRejReason,
  _swigc__p_FIX__CxlRejResponseTo,
  _swigc__p_FIX__CxlType,
  _swigc__p_FIX__DATA,
  _swigc__p_FIX__DAYOFMONTH,
  _swigc__p_FIX__DKReason,
  _swigc__p_FIX__DataDictionary,
  _swigc__p_FIX__DataDictionaryNotFound,
  _swigc__p_FIX__DateOfBirth,
  _swigc__p_FIX__DatedDate,
  _swigc__p_FIX__DayAvgPx,
  _swigc__p_FIX__DayBookingInst,
  _swigc__p_FIX__DayCumQty,
  _swigc__p_FIX__DayOrderQty,
  _swigc__p_FIX__DealingCapacity,
  _swigc__p_FIX__DefBidSize,
  _swigc__p_FIX__DefOfferSize,
  _swigc__p_FIX__DefaultApplExtID,
  _swigc__p_FIX__DefaultApplVerID,
  _swigc__p_FIX__DefaultCstmApplVerID,
  _swigc__p_FIX__DefaultVerIndicator,
  _swigc__p_FIX__DeleteReason,
  _swigc__p_FIX__DeliverToCompID,
  _swigc__p_FIX__DeliverToLocationID,
  _swigc__p_FIX__DeliverToSubID,
  _swigc__p_FIX__DeliveryDate,
  _swigc__p_FIX__DeliveryForm,
  _swigc__p_FIX__DeliveryType,
  _swigc__p_FIX__DerivFlexProductEligibilityIndicator,
  _swigc__p_FIX__DerivativeCFICode,
  _swigc__p_FIX__DerivativeCapPrice,
  _swigc__p_FIX__DerivativeContractMultiplier,
  _swigc__p_FIX__DerivativeContractMultiplierUnit,
  _swigc__p_FIX__DerivativeContractSettlMonth,
  _swigc__p_FIX__DerivativeCountryOfIssue,
  _swigc__p_FIX__DerivativeEncodedIssuer,
  _swigc__p_FIX__DerivativeEncodedIssuerLen,
  _swigc__p_FIX__DerivativeEncodedSecurityDesc,
  _swigc__p_FIX__DerivativeEncodedSecurityDescLen,
  _swigc__p_FIX__DerivativeEventDate,
  _swigc__p_FIX__DerivativeEventPx,
  _swigc__p_FIX__DerivativeEventText,
  _swigc__p_FIX__DerivativeEventTime,
  _swigc__p_FIX__DerivativeEventType,
  _swigc__p_FIX__DerivativeExerciseStyle,
  _swigc__p_FIX__DerivativeFloorPrice,
  _swigc__p_FIX__DerivativeFlowScheduleType,
  _swigc__p_FIX__DerivativeFuturesValuationMethod,
  _swigc__p_FIX__DerivativeInstrAttribType,
  _swigc__p_FIX__DerivativeInstrAttribValue,
  _swigc__p_FIX__DerivativeInstrRegistry,
  _swigc__p_FIX__DerivativeInstrmtAssignmentMethod,
  _swigc__p_FIX__DerivativeInstrumentPartyID,
  _swigc__p_FIX__DerivativeInstrumentPartyIDSource,
  _swigc__p_FIX__DerivativeInstrumentPartyRole,
  _swigc__p_FIX__DerivativeInstrumentPartySubID,
  _swigc__p_FIX__DerivativeInstrumentPartySubIDType,
  _swigc__p_FIX__DerivativeIssueDate,
  _swigc__p_FIX__DerivativeIssuer,
  _swigc__p_FIX__DerivativeListMethod,
  _swigc__p_FIX__DerivativeLocaleOfIssue,
  _swigc__p_FIX__DerivativeMaturityDate,
  _swigc__p_FIX__DerivativeMaturityMonthYear,
  _swigc__p_FIX__DerivativeMaturityTime,
  _swigc__p_FIX__DerivativeMinPriceIncrement,
  _swigc__p_FIX__DerivativeMinPriceIncrementAmount,
  _swigc__p_FIX__DerivativeNTPositionLimit,
  _swigc__p_FIX__DerivativeOptAttribute,
  _swigc__p_FIX__DerivativeOptPayAmount,
  _swigc__p_FIX__DerivativePositionLimit,
  _swigc__p_FIX__DerivativePriceQuoteMethod,
  _swigc__p_FIX__DerivativePriceUnitOfMeasure,
  _swigc__p_FIX__DerivativePriceUnitOfMeasureQty,
  _swigc__p_FIX__DerivativeProduct,
  _swigc__p_FIX__DerivativeProductComplex,
  _swigc__p_FIX__DerivativePutOrCall,
  _swigc__p_FIX__DerivativeSecurityAltID,
  _swigc__p_FIX__DerivativeSecurityAltIDSource,
  _swigc__p_FIX__DerivativeSecurityDesc,
  _swigc__p_FIX__DerivativeSecurityExchange,
  _swigc__p_FIX__DerivativeSecurityGroup,
  _swigc__p_FIX__DerivativeSecurityID,
  _swigc__p_FIX__DerivativeSecurityIDSource,
  _swigc__p_FIX__DerivativeSecurityListRequestType,
  _swigc__p_FIX__DerivativeSecurityStatus,
  _swigc__p_FIX__DerivativeSecuritySubType,
  _swigc__p_FIX__DerivativeSecurityType,
  _swigc__p_FIX__DerivativeSecurityXML,
  _swigc__p_FIX__DerivativeSecurityXMLLen,
  _swigc__p_FIX__DerivativeSecurityXMLSchema,
  _swigc__p_FIX__DerivativeSettlMethod,
  _swigc__p_FIX__DerivativeSettleOnOpenFlag,
  _swigc__p_FIX__DerivativeStateOrProvinceOfIssue,
  _swigc__p_FIX__DerivativeStrikeCurrency,
  _swigc__p_FIX__DerivativeStrikeMultiplier,
  _swigc__p_FIX__DerivativeStrikePrice,
  _swigc__p_FIX__DerivativeStrikeValue,
  _swigc__p_FIX__DerivativeSymbol,
  _swigc__p_FIX__DerivativeSymbolSfx,
  _swigc__p_FIX__DerivativeTimeUnit,
  _swigc__p_FIX__DerivativeUnitOfMeasure,
  _swigc__p_FIX__DerivativeUnitOfMeasureQty,
  _swigc__p_FIX__DerivativeValuationMethod,
  _swigc__p_FIX__Designation,
  _swigc__p_FIX__DeskID,
  _swigc__p_FIX__DeskOrderHandlingInst,
  _swigc__p_FIX__DeskType,
  _swigc__p_FIX__DeskTypeSource,
  _swigc__p_FIX__DetachmentPoint,
  _swigc__p_FIX__Dictionary,
  _swigc__p_FIX__Dictionary__Data__const_iterator,
  _swigc__p_FIX__DiscretionInst,
  _swigc__p_FIX__DiscretionLimitType,
  _swigc__p_FIX__DiscretionMoveType,
  _swigc__p_FIX__DiscretionOffset,
  _swigc__p_FIX__DiscretionOffsetType,
  _swigc__p_FIX__DiscretionOffsetValue,
  _swigc__p_FIX__DiscretionPrice,
  _swigc__p_FIX__DiscretionRoundDirection,
  _swigc__p_FIX__DiscretionScope,
  _swigc__p_FIX__DisplayHighQty,
  _swigc__p_FIX__DisplayLowQty,
  _swigc__p_FIX__DisplayMethod,
  _swigc__p_FIX__DisplayMinIncr,
  _swigc__p_FIX__DisplayQty,
  _swigc__p_FIX__DisplayWhen,
  _swigc__p_FIX__DistribPaymentMethod,
  _swigc__p_FIX__DistribPercentage,
  _swigc__p_FIX__DividendYield,
  _swigc__p_FIX__DlvyInst,
  _swigc__p_FIX__DlvyInstType,
  _swigc__p_FIX__DoNotSend,
  _swigc__p_FIX__DoubleField,
  _swigc__p_FIX__DueToRelated,
  _swigc__p_FIX__DuplicateFieldNumber,
  _swigc__p_FIX__EFPTrackingError,
  _swigc__p_FIX__EXCHANGE,
  _swigc__p_FIX__EffectiveTime,
  _swigc__p_FIX__EmailThreadID,
  _swigc__p_FIX__EmailType,
  _swigc__p_FIX__EncodedAllocText,
  _swigc__p_FIX__EncodedAllocTextLen,
  _swigc__p_FIX__EncodedHeadline,
  _swigc__p_FIX__EncodedHeadlineLen,
  _swigc__p_FIX__EncodedIssuer,
  _swigc__p_FIX__EncodedIssuerLen,
  _swigc__p_FIX__EncodedLegIssuer,
  _swigc__p_FIX__EncodedLegIssuerLen,
  _swigc__p_FIX__EncodedLegSecurityDesc,
  _swigc__p_FIX__EncodedLegSecurityDescLen,
  _swigc__p_FIX__EncodedListExecInst,
  _swigc__p_FIX__EncodedListExecInstLen,
  _swigc__p_FIX__EncodedListStatusText,
  _swigc__p_FIX__EncodedListStatusTextLen,
  _swigc__p_FIX__EncodedMktSegmDesc,
  _swigc__p_FIX__EncodedMktSegmDescLen,
  _swigc__p_FIX__EncodedSecurityDesc,
  _swigc__p_FIX__EncodedSecurityDescLen,
  _swigc__p_FIX__EncodedSecurityListDesc,
  _swigc__p_FIX__EncodedSecurityListDescLen,
  _swigc__p_FIX__EncodedSubject,
  _swigc__p_FIX__EncodedSubjectLen,
  _swigc__p_FIX__EncodedSymbol,
  _swigc__p_FIX__EncodedSymbolLen,
  _swigc__p_FIX__EncodedText,
  _swigc__p_FIX__EncodedTextLen,
  _swigc__p_FIX__EncodedUnderlyingIssuer,
  _swigc__p_FIX__EncodedUnderlyingIssuerLen,
  _swigc__p_FIX__EncodedUnderlyingSecurityDesc,
  _swigc__p_FIX__EncodedUnderlyingSecurityDescLen,
  _swigc__p_FIX__EncryptMethod,
  _swigc__p_FIX__EncryptedNewPassword,
  _swigc__p_FIX__EncryptedNewPasswordLen,
  _swigc__p_FIX__EncryptedPassword,
  _swigc__p_FIX__EncryptedPasswordLen,
  _swigc__p_FIX__EncryptedPasswordMethod,
  _swigc__p_FIX__EndAccruedInterestAmt,
  _swigc__p_FIX__EndCash,
  _swigc__p_FIX__EndDate,
  _swigc__p_FIX__EndMaturityMonthYear,
  _swigc__p_FIX__EndSeqNo,
  _swigc__p_FIX__EndStrikePxRange,
  _swigc__p_FIX__EndTickPriceRange,
  _swigc__p_FIX__EventDate,
  _swigc__p_FIX__EventPx,
  _swigc__p_FIX__EventText,
  _swigc__p_FIX__EventTime,
  _swigc__p_FIX__EventType,
  _swigc__p_FIX__ExDate,
  _swigc__p_FIX__ExDestination,
  _swigc__p_FIX__ExDestinationIDSource,
  _swigc__p_FIX__Exception,
  _swigc__p_FIX__ExchangeForPhysical,
  _swigc__p_FIX__ExchangeRule,
  _swigc__p_FIX__ExchangeSpecialInstructions,
  _swigc__p_FIX__ExecAckStatus,
  _swigc__p_FIX__ExecBroker,
  _swigc__p_FIX__ExecID,
  _swigc__p_FIX__ExecInst,
  _swigc__p_FIX__ExecInstValue,
  _swigc__p_FIX__ExecPriceAdjustment,
  _swigc__p_FIX__ExecPriceType,
  _swigc__p_FIX__ExecRefID,
  _swigc__p_FIX__ExecRestatementReason,
  _swigc__p_FIX__ExecTransType,
  _swigc__p_FIX__ExecType,
  _swigc__p_FIX__ExecValuationPoint,
  _swigc__p_FIX__ExerciseMethod,
  _swigc__p_FIX__ExerciseStyle,
  _swigc__p_FIX__ExpQty,
  _swigc__p_FIX__ExpType,
  _swigc__p_FIX__ExpirationCycle,
  _swigc__p_FIX__ExpirationQtyType,
  _swigc__p_FIX__ExpireDate,
  _swigc__p_FIX__ExpireTime,
  _swigc__p_FIX__FLOAT,
  _swigc__p_FIX__Factor,
  _swigc__p_FIX__FairValue,
  _swigc__p_FIX__FeeMultiplier,
  _swigc__p_FIX__FieldBase,
  _swigc__p_FIX__FieldConvertError,
  _swigc__p_FIX__FieldMap,
  _swigc__p_FIX__FieldMap__Fields__const_iterator,
  _swigc__p_FIX__FieldMap__Groups__const_iterator,
  _swigc__p_FIX__FieldNotFound,
  _swigc__p_FIX__FileLog,
  _swigc__p_FIX__FileLogFactory,
  _swigc__p_FIX__FileStore,
  _swigc__p_FIX__FileStoreFactory,
  _swigc__p_FIX__FillExecID,
  _swigc__p_FIX__FillLiquidityInd,
  _swigc__p_FIX__FillPx,
  _swigc__p_FIX__FillQty,
  _swigc__p_FIX__FinancialStatus,
  _swigc__p_FIX__FirmTradeID,
  _swigc__p_FIX__FirstPx,
  _swigc__p_FIX__FlexProductEligibilityIndicator,
  _swigc__p_FIX__FlexibleIndicator,
  _swigc__p_FIX__FloorPrice,
  _swigc__p_FIX__FlowScheduleType,
  _swigc__p_FIX__ForexReq,
  _swigc__p_FIX__FundRenewWaiv,
  _swigc__p_FIX__FutSettDate,
  _swigc__p_FIX__FutSettDate2,
  _swigc__p_FIX__FuturesValuationMethod,
  _swigc__p_FIX__GTBookingInst,
  _swigc__p_FIX__GapFillFlag,
  _swigc__p_FIX__GrossTradeAmt,
  _swigc__p_FIX__Group,
  _swigc__p_FIX__HaltReasonChar,
  _swigc__p_FIX__HaltReasonInt,
  _swigc__p_FIX__HandlInst,
  _swigc__p_FIX__Headline,
  _swigc__p_FIX__HeartBtInt,
  _swigc__p_FIX__HighLimitPrice,
  _swigc__p_FIX__HighPx,
  _swigc__p_FIX__HopCompID,
  _swigc__p_FIX__HopRefID,
  _swigc__p_FIX__HopSendingTime,
  _swigc__p_FIX__HostCrossID,
  _swigc__p_FIX__IDSource,
  _swigc__p_FIX__INT,
  _swigc__p_FIX__IOException,
  _swigc__p_FIX__IOIID,
  _swigc__p_FIX__IOINaturalFlag,
  _swigc__p_FIX__IOIOthSvc,
  _swigc__p_FIX__IOIQltyInd,
  _swigc__p_FIX__IOIQty,
  _swigc__p_FIX__IOIQualifier,
  _swigc__p_FIX__IOIRefID,
  _swigc__p_FIX__IOIShares,
  _swigc__p_FIX__IOITransType,
  _swigc__p_FIX__IOIid,
  _swigc__p_FIX__ImpliedMarketIndicator,
  _swigc__p_FIX__InViewOfCommon,
  _swigc__p_FIX__IncTaxInd,
  _swigc__p_FIX__IncorrectDataFormat,
  _swigc__p_FIX__IncorrectMessageStructure,
  _swigc__p_FIX__IncorrectTagValue,
  _swigc__p_FIX__IndividualAllocID,
  _swigc__p_FIX__IndividualAllocRejCode,
  _swigc__p_FIX__IndividualAllocType,
  _swigc__p_FIX__Initiator,
  _swigc__p_FIX__InputSource,
  _swigc__p_FIX__InstrAttribType,
  _swigc__p_FIX__InstrAttribValue,
  _swigc__p_FIX__InstrRegistry,
  _swigc__p_FIX__InstrmtAssignmentMethod,
  _swigc__p_FIX__InstrumentPartyID,
  _swigc__p_FIX__InstrumentPartyIDSource,
  _swigc__p_FIX__InstrumentPartyRole,
  _swigc__p_FIX__InstrumentPartySubID,
  _swigc__p_FIX__InstrumentPartySubIDType,
  _swigc__p_FIX__IntField,
  _swigc__p_FIX__InterestAccrualDate,
  _swigc__p_FIX__InterestAtMaturity,
  _swigc__p_FIX__InvalidMessage,
  _swigc__p_FIX__InvalidMessageType,
  _swigc__p_FIX__InvalidTagNumber,
  _swigc__p_FIX__InvestorCountryOfResidence,
  _swigc__p_FIX__IssueDate,
  _swigc__p_FIX__Issuer,
  _swigc__p_FIX__LANGUAGE,
  _swigc__p_FIX__LENGTH,
  _swigc__p_FIX__LOCALMKTDATE,
  _swigc__p_FIX__LanguageCode,
  _swigc__p_FIX__LastCapacity,
  _swigc__p_FIX__LastForwardPoints,
  _swigc__p_FIX__LastForwardPoints2,
  _swigc__p_FIX__LastFragment,
  _swigc__p_FIX__LastLiquidityInd,
  _swigc__p_FIX__LastMkt,
  _swigc__p_FIX__LastMsgSeqNumProcessed,
  _swigc__p_FIX__LastNetworkResponseID,
  _swigc__p_FIX__LastParPx,
  _swigc__p_FIX__LastPx,
  _swigc__p_FIX__LastQty,
  _swigc__p_FIX__LastRptRequested,
  _swigc__p_FIX__LastShares,
  _swigc__p_FIX__LastSpotRate,
  _swigc__p_FIX__LastSwapPoints,
  _swigc__p_FIX__LastUpdateTime,
  _swigc__p_FIX__LateIndicator,
  _swigc__p_FIX__LeavesQty,
  _swigc__p_FIX__LegAllocAccount,
  _swigc__p_FIX__LegAllocAcctIDSource,
  _swigc__p_FIX__LegAllocID,
  _swigc__p_FIX__LegAllocQty,
  _swigc__p_FIX__LegAllocSettlCurrency,
  _swigc__p_FIX__LegBenchmarkCurveCurrency,
  _swigc__p_FIX__LegBenchmarkCurveName,
  _swigc__p_FIX__LegBenchmarkCurvePoint,
  _swigc__p_FIX__LegBenchmarkPrice,
  _swigc__p_FIX__LegBenchmarkPriceType,
  _swigc__p_FIX__LegBidForwardPoints,
  _swigc__p_FIX__LegBidPx,
  _swigc__p_FIX__LegCFICode,
  _swigc__p_FIX__LegCalculatedCcyLastQty,
  _swigc__p_FIX__LegContractMultiplier,
  _swigc__p_FIX__LegContractMultiplierUnit,
  _swigc__p_FIX__LegContractSettlMonth,
  _swigc__p_FIX__LegCountryOfIssue,
  _swigc__p_FIX__LegCouponPaymentDate,
  _swigc__p_FIX__LegCouponRate,
  _swigc__p_FIX__LegCoveredOrUncovered,
  _swigc__p_FIX__LegCreditRating,
  _swigc__p_FIX__LegCurrency,
  _swigc__p_FIX__LegCurrencyRatio,
  _swigc__p_FIX__LegDatedDate,
  _swigc__p_FIX__LegDividendYield,
  _swigc__p_FIX__LegExecInst,
  _swigc__p_FIX__LegExerciseStyle,
  _swigc__p_FIX__LegFactor,
  _swigc__p_FIX__LegFlowScheduleType,
  _swigc__p_FIX__LegFutSettDate,
  _swigc__p_FIX__LegGrossTradeAmt,
  _swigc__p_FIX__LegIOIQty,
  _swigc__p_FIX__LegIndividualAllocID,
  _swigc__p_FIX__LegInstrRegistry,
  _swigc__p_FIX__LegInterestAccrualDate,
  _swigc__p_FIX__LegIssueDate,
  _swigc__p_FIX__LegIssuer,
  _swigc__p_FIX__LegLastForwardPoints,
  _swigc__p_FIX__LegLastPx,
  _swigc__p_FIX__LegLastQty,
  _swigc__p_FIX__LegLocaleOfIssue,
  _swigc__p_FIX__LegMaturityDate,
  _swigc__p_FIX__LegMaturityMonthYear,
  _swigc__p_FIX__LegMaturityTime,
  _swigc__p_FIX__LegNumber,
  _swigc__p_FIX__LegOfferForwardPoints,
  _swigc__p_FIX__LegOfferPx,
  _swigc__p_FIX__LegOptAttribute,
  _swigc__p_FIX__LegOptionRatio,
  _swigc__p_FIX__LegOrderQty,
  _swigc__p_FIX__LegPool,
  _swigc__p_FIX__LegPositionEffect,
  _swigc__p_FIX__LegPrice,
  _swigc__p_FIX__LegPriceType,
  _swigc__p_FIX__LegPriceUnitOfMeasure,
  _swigc__p_FIX__LegPriceUnitOfMeasureQty,
  _swigc__p_FIX__LegProduct,
  _swigc__p_FIX__LegPutOrCall,
  _swigc__p_FIX__LegQty,
  _swigc__p_FIX__LegRatioQty,
  _swigc__p_FIX__LegRedemptionDate,
  _swigc__p_FIX__LegRefID,
  _swigc__p_FIX__LegRepoCollateralSecurityType,
  _swigc__p_FIX__LegReportID,
  _swigc__p_FIX__LegRepurchaseRate,
  _swigc__p_FIX__LegRepurchaseTerm,
  _swigc__p_FIX__LegSecurityAltID,
  _swigc__p_FIX__LegSecurityAltIDSource,
  _swigc__p_FIX__LegSecurityDesc,
  _swigc__p_FIX__LegSecurityExchange,
  _swigc__p_FIX__LegSecurityID,
  _swigc__p_FIX__LegSecurityIDSource,
  _swigc__p_FIX__LegSecuritySubType,
  _swigc__p_FIX__LegSecurityType,
  _swigc__p_FIX__LegSettlCurrency,
  _swigc__p_FIX__LegSettlDate,
  _swigc__p_FIX__LegSettlType,
  _swigc__p_FIX__LegSettlmntTyp,
  _swigc__p_FIX__LegSide,
  _swigc__p_FIX__LegStateOrProvinceOfIssue,
  _swigc__p_FIX__LegStipulationType,
  _swigc__p_FIX__LegStipulationValue,
  _swigc__p_FIX__LegStrikeCurrency,
  _swigc__p_FIX__LegStrikePrice,
  _swigc__p_FIX__LegSwapType,
  _swigc__p_FIX__LegSymbol,
  _swigc__p_FIX__LegSymbolSfx,
  _swigc__p_FIX__LegTimeUnit,
  _swigc__p_FIX__LegUnitOfMeasure,
  _swigc__p_FIX__LegUnitOfMeasureQty,
  _swigc__p_FIX__LegVolatility,
  _swigc__p_FIX__LegalConfirm,
  _swigc__p_FIX__LinesOfText,
  _swigc__p_FIX__LiquidityIndType,
  _swigc__p_FIX__LiquidityNumSecurities,
  _swigc__p_FIX__LiquidityPctHigh,
  _swigc__p_FIX__LiquidityPctLow,
  _swigc__p_FIX__LiquidityValue,
  _swigc__p_FIX__ListExecInst,
  _swigc__p_FIX__ListExecInstType,
  _swigc__p_FIX__ListID,
  _swigc__p_FIX__ListMethod,
  _swigc__p_FIX__ListName,
  _swigc__p_FIX__ListNoOrds,
  _swigc__p_FIX__ListOrderStatus,
  _swigc__p_FIX__ListRejectReason,
  _swigc__p_FIX__ListSeqNo,
  _swigc__p_FIX__ListStatusText,
  _swigc__p_FIX__ListStatusType,
  _swigc__p_FIX__ListUpdateAction,
  _swigc__p_FIX__LocaleOfIssue,
  _swigc__p_FIX__LocateReqd,
  _swigc__p_FIX__LocationID,
  _swigc__p_FIX__Log,
  _swigc__p_FIX__LogFactory,
  _swigc__p_FIX__LongQty,
  _swigc__p_FIX__LotType,
  _swigc__p_FIX__LowLimitPrice,
  _swigc__p_FIX__LowPx,
  _swigc__p_FIX__MDBookType,
  _swigc__p_FIX__MDEntryBuyer,
  _swigc__p_FIX__MDEntryDate,
  _swigc__p_FIX__MDEntryForwardPoints,
  _swigc__p_FIX__MDEntryID,
  _swigc__p_FIX__MDEntryOriginator,
  _swigc__p_FIX__MDEntryPositionNo,
  _swigc__p_FIX__MDEntryPx,
  _swigc__p_FIX__MDEntryRefID,
  _swigc__p_FIX__MDEntrySeller,
  _swigc__p_FIX__MDEntrySize,
  _swigc__p_FIX__MDEntrySpotRate,
  _swigc__p_FIX__MDEntryTime,
  _swigc__p_FIX__MDEntryType,
  _swigc__p_FIX__MDFeedType,
  _swigc__p_FIX__MDImplicitDelete,
  _swigc__p_FIX__MDMkt,
  _swigc__p_FIX__MDOriginType,
  _swigc__p_FIX__MDPriceLevel,
  _swigc__p_FIX__MDQuoteType,
  _swigc__p_FIX__MDReportID,
  _swigc__p_FIX__MDReqID,
  _swigc__p_FIX__MDReqRejReason,
  _swigc__p_FIX__MDSecSize,
  _swigc__p_FIX__MDSecSizeType,
  _swigc__p_FIX__MDStreamID,
  _swigc__p_FIX__MDSubBookType,
  _swigc__p_FIX__MDUpdateAction,
  _swigc__p_FIX__MDUpdateType,
  _swigc__p_FIX__MONTHYEAR,
  _swigc__p_FIX__MULTIPLECHARVALUE,
  _swigc__p_FIX__MULTIPLESTRINGVALUE,
  _swigc__p_FIX__MULTIPLEVALUESTRING,
  _swigc__p_FIX__MailingDtls,
  _swigc__p_FIX__MailingInst,
  _swigc__p_FIX__ManualOrderIndicator,
  _swigc__p_FIX__MarginExcess,
  _swigc__p_FIX__MarginRatio,
  _swigc__p_FIX__MarketDepth,
  _swigc__p_FIX__MarketID,
  _swigc__p_FIX__MarketReportID,
  _swigc__p_FIX__MarketReqID,
  _swigc__p_FIX__MarketSegmentDesc,
  _swigc__p_FIX__MarketSegmentID,
  _swigc__p_FIX__MarketUpdateAction,
  _swigc__p_FIX__MassActionRejectReason,
  _swigc__p_FIX__MassActionReportID,
  _swigc__p_FIX__MassActionResponse,
  _swigc__p_FIX__MassActionScope,
  _swigc__p_FIX__MassActionType,
  _swigc__p_FIX__MassCancelRejectReason,
  _swigc__p_FIX__MassCancelRequestType,
  _swigc__p_FIX__MassCancelResponse,
  _swigc__p_FIX__MassStatusReqID,
  _swigc__p_FIX__MassStatusReqType,
  _swigc__p_FIX__MatchAlgorithm,
  _swigc__p_FIX__MatchIncrement,
  _swigc__p_FIX__MatchStatus,
  _swigc__p_FIX__MatchType,
  _swigc__p_FIX__MaturityDate,
  _swigc__p_FIX__MaturityDay,
  _swigc__p_FIX__MaturityMonthYear,
  _swigc__p_FIX__MaturityMonthYearFormat,
  _swigc__p_FIX__MaturityMonthYearIncrement,
  _swigc__p_FIX__MaturityMonthYearIncrementUnits,
  _swigc__p_FIX__MaturityNetMoney,
  _swigc__p_FIX__MaturityRuleID,
  _swigc__p_FIX__MaturityTime,
  _swigc__p_FIX__MaxFloor,
  _swigc__p_FIX__MaxMessageSize,
  _swigc__p_FIX__MaxPriceLevels,
  _swigc__p_FIX__MaxPriceVariation,
  _swigc__p_FIX__MaxShow,
  _swigc__p_FIX__MaxTradeVol,
  _swigc__p_FIX__MemoryStore,
  _swigc__p_FIX__MemoryStoreFactory,
  _swigc__p_FIX__Message,
  _swigc__p_FIX__MessageEncoding,
  _swigc__p_FIX__MessageEventSource,
  _swigc__p_FIX__MessageParseError,
  _swigc__p_FIX__MessageStore,
  _swigc__p_FIX__MessageStoreExceptionWrapper,
  _swigc__p_FIX__MessageStoreFactory,
  _swigc__p_FIX__MessageStoreFactoryExceptionWrapper,
  _swigc__p_FIX__MidPx,
  _swigc__p_FIX__MidYield,
  _swigc__p_FIX__MinBidSize,
  _swigc__p_FIX__MinLotSize,
  _swigc__p_FIX__MinOfferSize,
  _swigc__p_FIX__MinPriceIncrement,
  _swigc__p_FIX__MinPriceIncrementAmount,
  _swigc__p_FIX__MinQty,
  _swigc__p_FIX__MinTradeVol,
  _swigc__p_FIX__MiscFeeAmt,
  _swigc__p_FIX__MiscFeeBasis,
  _swigc__p_FIX__MiscFeeCurr,
  _swigc__p_FIX__MiscFeeType,
  _swigc__p_FIX__MktBidPx,
  _swigc__p_FIX__MktOfferPx,
  _swigc__p_FIX__ModelType,
  _swigc__p_FIX__MoneyLaunderingStatus,
  _swigc__p_FIX__MsgDirection,
  _swigc__p_FIX__MsgSeqNum,
  _swigc__p_FIX__MsgType,
  _swigc__p_FIX__MultiLegReportingType,
  _swigc__p_FIX__MultiLegRptTypeReq,
  _swigc__p_FIX__MultilegModel,
  _swigc__p_FIX__MultilegPriceMethod,
  _swigc__p_FIX__NTPositionLimit,
  _swigc__p_FIX__NUMINGROUP,
  _swigc__p_FIX__Nested2PartyID,
  _swigc__p_FIX__Nested2PartyIDSource,
  _swigc__p_FIX__Nested2PartyRole,
  _swigc__p_FIX__Nested2PartySubID,
  _swigc__p_FIX__Nested2PartySubIDType,
  _swigc__p_FIX__Nested3PartyID,
  _swigc__p_FIX__Nested3PartyIDSource,
  _swigc__p_FIX__Nested3PartyRole,
  _swigc__p_FIX__Nested3PartySubID,
  _swigc__p_FIX__Nested3PartySubIDType,
  _swigc__p_FIX__Nested4PartyID,
  _swigc__p_FIX__Nested4PartyIDSource,
  _swigc__p_FIX__Nested4PartyRole,
  _swigc__p_FIX__Nested4PartySubID,
  _swigc__p_FIX__Nested4PartySubIDType,
  _swigc__p_FIX__NestedInstrAttribType,
  _swigc__p_FIX__NestedInstrAttribValue,
  _swigc__p_FIX__NestedPartyID,
  _swigc__p_FIX__NestedPartyIDSource,
  _swigc__p_FIX__NestedPartyRole,
  _swigc__p_FIX__NestedPartySubID,
  _swigc__p_FIX__NestedPartySubIDType,
  _swigc__p_FIX__NetChgPrevDay,
  _swigc__p_FIX__NetGrossInd,
  _swigc__p_FIX__NetMoney,
  _swigc__p_FIX__NetworkRequestID,
  _swigc__p_FIX__NetworkRequestType,
  _swigc__p_FIX__NetworkResponseID,
  _swigc__p_FIX__NetworkStatusResponseType,
  _swigc__p_FIX__NewPassword,
  _swigc__p_FIX__NewSeqNo,
  _swigc__p_FIX__NewsCategory,
  _swigc__p_FIX__NewsID,
  _swigc__p_FIX__NewsRefID,
  _swigc__p_FIX__NewsRefType,
  _swigc__p_FIX__NextExpectedMsgSeqNum,
  _swigc__p_FIX__NoAffectedOrders,
  _swigc__p_FIX__NoAllocs,
  _swigc__p_FIX__NoAltMDSource,
  _swigc__p_FIX__NoApplIDs,
  _swigc__p_FIX__NoAsgnReqs,
  _swigc__p_FIX__NoBidComponents,
  _swigc__p_FIX__NoBidDescriptors,
  _swigc__p_FIX__NoCapacities,
  _swigc__p_FIX__NoClearingInstructions,
  _swigc__p_FIX__NoCollInquiryQualifier,
  _swigc__p_FIX__NoCompIDs,
  _swigc__p_FIX__NoComplexEventDates,
  _swigc__p_FIX__NoComplexEventTimes,
  _swigc__p_FIX__NoComplexEvents,
  _swigc__p_FIX__NoContAmts,
  _swigc__p_FIX__NoContextPartyIDs,
  _swigc__p_FIX__NoContextPartySubIDs,
  _swigc__p_FIX__NoContraBrokers,
  _swigc__p_FIX__NoDates,
  _swigc__p_FIX__NoDerivativeEvents,
  _swigc__p_FIX__NoDerivativeInstrAttrib,
  _swigc__p_FIX__NoDerivativeInstrumentParties,
  _swigc__p_FIX__NoDerivativeInstrumentPartySubIDs,
  _swigc__p_FIX__NoDerivativeSecurityAltID,
  _swigc__p_FIX__NoDistribInsts,
  _swigc__p_FIX__NoDlvyInst,
  _swigc__p_FIX__NoEvents,
  _swigc__p_FIX__NoExecInstRules,
  _swigc__p_FIX__NoExecs,
  _swigc__p_FIX__NoExpiration,
  _swigc__p_FIX__NoFills,
  _swigc__p_FIX__NoHops,
  _swigc__p_FIX__NoIOIQualifiers,
  _swigc__p_FIX__NoInstrAttrib,
  _swigc__p_FIX__NoInstrumentParties,
  _swigc__p_FIX__NoInstrumentPartySubIDs,
  _swigc__p_FIX__NoLegAllocs,
  _swigc__p_FIX__NoLegSecurityAltID,
  _swigc__p_FIX__NoLegStipulations,
  _swigc__p_FIX__NoLegs,
  _swigc__p_FIX__NoLinesOfText,
  _swigc__p_FIX__NoLotTypeRules,
  _swigc__p_FIX__NoMDEntries,
  _swigc__p_FIX__NoMDEntryTypes,
  _swigc__p_FIX__NoMDFeedTypes,
  _swigc__p_FIX__NoMarketSegments,
  _swigc__p_FIX__NoMatchRules,
  _swigc__p_FIX__NoMaturityRules,
  _swigc__p_FIX__NoMiscFees,
  _swigc__p_FIX__NoMsgTypes,
  _swigc__p_FIX__NoNested2PartyIDs,
  _swigc__p_FIX__NoNested2PartySubIDs,
  _swigc__p_FIX__NoNested3PartyIDs,
  _swigc__p_FIX__NoNested3PartySubIDs,
  _swigc__p_FIX__NoNested4PartyIDs,
  _swigc__p_FIX__NoNested4PartySubIDs,
  _swigc__p_FIX__NoNestedInstrAttrib,
  _swigc__p_FIX__NoNestedPartyIDs,
  _swigc__p_FIX__NoNestedPartySubIDs,
  _swigc__p_FIX__NoNewsRefIDs,
  _swigc__p_FIX__NoNotAffectedOrders,
  _swigc__p_FIX__NoOfLegUnderlyings,
  _swigc__p_FIX__NoOfSecSizes,
  _swigc__p_FIX__NoOrdTypeRules,
  _swigc__p_FIX__NoOrders,
  _swigc__p_FIX__NoPartyAltIDs,
  _swigc__p_FIX__NoPartyAltSubIDs,
  _swigc__p_FIX__NoPartyIDs,
  _swigc__p_FIX__NoPartyList,
  _swigc__p_FIX__NoPartyListResponseTypes,
  _swigc__p_FIX__NoPartyRelationships,
  _swigc__p_FIX__NoPartySubIDs,
  _swigc__p_FIX__NoPosAmt,
  _swigc__p_FIX__NoPositions,
  _swigc__p_FIX__NoQuoteEntries,
  _swigc__p_FIX__NoQuoteQualifiers,
  _swigc__p_FIX__NoQuoteSets,
  _swigc__p_FIX__NoRateSources,
  _swigc__p_FIX__NoRegistDtls,
  _swigc__p_FIX__NoRelatedContextPartyIDs,
  _swigc__p_FIX__NoRelatedContextPartySubIDs,
  _swigc__p_FIX__NoRelatedPartyAltIDs,
  _swigc__p_FIX__NoRelatedPartyAltSubIDs,
  _swigc__p_FIX__NoRelatedPartyIDs,
  _swigc__p_FIX__NoRelatedPartySubIDs,
  _swigc__p_FIX__NoRelatedSym,
  _swigc__p_FIX__NoRelationshipRiskInstruments,
  _swigc__p_FIX__NoRelationshipRiskLimits,
  _swigc__p_FIX__NoRelationshipRiskSecurityAltID,
  _swigc__p_FIX__NoRelationshipRiskWarningLevels,
  _swigc__p_FIX__NoRequestedPartyRoles,
  _swigc__p_FIX__NoRiskInstruments,
  _swigc__p_FIX__NoRiskLimits,
  _swigc__p_FIX__NoRiskSecurityAltID,
  _swigc__p_FIX__NoRiskWarningLevels,
  _swigc__p_FIX__NoRootPartyIDs,
  _swigc__p_FIX__NoRootPartySubIDs,
  _swigc__p_FIX__NoRoutingIDs,
  _swigc__p_FIX__NoRpts,
  _swigc__p_FIX__NoSecurityAltID,
  _swigc__p_FIX__NoSecurityTypes,
  _swigc__p_FIX__NoSettlDetails,
  _swigc__p_FIX__NoSettlInst,
  _swigc__p_FIX__NoSettlOblig,
  _swigc__p_FIX__NoSettlPartyIDs,
  _swigc__p_FIX__NoSettlPartySubIDs,
  _swigc__p_FIX__NoSideTrdRegTS,
  _swigc__p_FIX__NoSides,
  _swigc__p_FIX__NoStatsIndicators,
  _swigc__p_FIX__NoStipulations,
  _swigc__p_FIX__NoStrategyParameters,
  _swigc__p_FIX__NoStrikeRules,
  _swigc__p_FIX__NoStrikes,
  _swigc__p_FIX__NoTagValue,
  _swigc__p_FIX__NoTargetPartyIDs,
  _swigc__p_FIX__NoTickRules,
  _swigc__p_FIX__NoTimeInForceRules,
  _swigc__p_FIX__NoTrades,
  _swigc__p_FIX__NoTradingSessionRules,
  _swigc__p_FIX__NoTradingSessions,
  _swigc__p_FIX__NoTrdRegTimestamps,
  _swigc__p_FIX__NoTrdRepIndicators,
  _swigc__p_FIX__NoUnderlyingAmounts,
  _swigc__p_FIX__NoUnderlyingLegSecurityAltID,
  _swigc__p_FIX__NoUnderlyingSecurityAltID,
  _swigc__p_FIX__NoUnderlyingStips,
  _swigc__p_FIX__NoUnderlyings,
  _swigc__p_FIX__NoUndlyInstrumentParties,
  _swigc__p_FIX__NoUndlyInstrumentPartySubIDs,
  _swigc__p_FIX__NotAffOrigClOrdID,
  _swigc__p_FIX__NotAffectedOrderID,
  _swigc__p_FIX__NotifyBrokerOfCredit,
  _swigc__p_FIX__NotionalPercentageOutstanding,
  _swigc__p_FIX__NullApplication,
  _swigc__p_FIX__NullLog,
  _swigc__p_FIX__NumBidders,
  _swigc__p_FIX__NumDaysInterest,
  _swigc__p_FIX__NumTickets,
  _swigc__p_FIX__NumberOfOrders,
  _swigc__p_FIX__OddLot,
  _swigc__p_FIX__OfferForwardPoints,
  _swigc__p_FIX__OfferForwardPoints2,
  _swigc__p_FIX__OfferPx,
  _swigc__p_FIX__OfferSize,
  _swigc__p_FIX__OfferSpotRate,
  _swigc__p_FIX__OfferSwapPoints,
  _swigc__p_FIX__OfferYield,
  _swigc__p_FIX__OnBehalfOfCompID,
  _swigc__p_FIX__OnBehalfOfLocationID,
  _swigc__p_FIX__OnBehalfOfSendingTime,
  _swigc__p_FIX__OnBehalfOfSubID,
  _swigc__p_FIX__OpenClose,
  _swigc__p_FIX__OpenCloseSettlFlag,
  _swigc__p_FIX__OpenCloseSettleFlag,
  _swigc__p_FIX__OpenInterest,
  _swigc__p_FIX__OptAttribute,
  _swigc__p_FIX__OptPayAmount,
  _swigc__p_FIX__OptPayoutAmount,
  _swigc__p_FIX__OptPayoutType,
  _swigc__p_FIX__OrdRejReason,
  _swigc__p_FIX__OrdStatus,
  _swigc__p_FIX__OrdStatusReqID,
  _swigc__p_FIX__OrdType,
  _swigc__p_FIX__OrderAvgPx,
  _swigc__p_FIX__OrderBookingQty,
  _swigc__p_FIX__OrderCapacity,
  _swigc__p_FIX__OrderCapacityQty,
  _swigc__p_FIX__OrderCategory,
  _swigc__p_FIX__OrderDelay,
  _swigc__p_FIX__OrderDelayUnit,
  _swigc__p_FIX__OrderHandlingInstSource,
  _swigc__p_FIX__OrderID,
  _swigc__p_FIX__OrderInputDevice,
  _swigc__p_FIX__OrderPercent,
  _swigc__p_FIX__OrderQty,
  _swigc__p_FIX__OrderQty2,
  _swigc__p_FIX__OrderRestrictions,
  _swigc__p_FIX__OrigClOrdID,
  _swigc__p_FIX__OrigCrossID,
  _swigc__p_FIX__OrigCustOrderCapacity,
  _swigc__p_FIX__OrigOrdModTime,
  _swigc__p_FIX__OrigPosReqRefID,
  _swigc__p_FIX__OrigSecondaryTradeID,
  _swigc__p_FIX__OrigSendingTime,
  _swigc__p_FIX__OrigTime,
  _swigc__p_FIX__OrigTradeDate,
  _swigc__p_FIX__OrigTradeHandlingInstr,
  _swigc__p_FIX__OrigTradeID,
  _swigc__p_FIX__OriginalNotionalPercentageOutstanding,
  _swigc__p_FIX__OutMainCntryUIndex,
  _swigc__p_FIX__OutsideIndexPct,
  _swigc__p_FIX__OwnerType,
  _swigc__p_FIX__OwnershipType,
  _swigc__p_FIX__PERCENTAGE,
  _swigc__p_FIX__PRICE,
  _swigc__p_FIX__PRICEOFFSET,
  _swigc__p_FIX__ParentMktSegmID,
  _swigc__p_FIX__ParticipationRate,
  _swigc__p_FIX__PartyAltID,
  _swigc__p_FIX__PartyAltIDSource,
  _swigc__p_FIX__PartyAltSubID,
  _swigc__p_FIX__PartyAltSubIDType,
  _swigc__p_FIX__PartyDetailsListReportID,
  _swigc__p_FIX__PartyDetailsListRequestID,
  _swigc__p_FIX__PartyDetailsRequestResult,
  _swigc__p_FIX__PartyID,
  _swigc__p_FIX__PartyIDSource,
  _swigc__p_FIX__PartyListResponseType,
  _swigc__p_FIX__PartyRelationship,
  _swigc__p_FIX__PartyRole,
  _swigc__p_FIX__PartySubID,
  _swigc__p_FIX__PartySubIDType,
  _swigc__p_FIX__Password,
  _swigc__p_FIX__PaymentDate,
  _swigc__p_FIX__PaymentMethod,
  _swigc__p_FIX__PaymentRef,
  _swigc__p_FIX__PaymentRemitterID,
  _swigc__p_FIX__PctAtRisk,
  _swigc__p_FIX__PegDifference,
  _swigc__p_FIX__PegLimitType,
  _swigc__p_FIX__PegMoveType,
  _swigc__p_FIX__PegOffsetType,
  _swigc__p_FIX__PegOffsetValue,
  _swigc__p_FIX__PegPriceType,
  _swigc__p_FIX__PegRoundDirection,
  _swigc__p_FIX__PegScope,
  _swigc__p_FIX__PegSecurityDesc,
  _swigc__p_FIX__PegSecurityID,
  _swigc__p_FIX__PegSecurityIDSource,
  _swigc__p_FIX__PegSymbol,
  _swigc__p_FIX__PeggedPrice,
  _swigc__p_FIX__PeggedRefPrice,
  _swigc__p_FIX__Pool,
  _swigc__p_FIX__PosAmt,
  _swigc__p_FIX__PosAmtType,
  _swigc__p_FIX__PosMaintAction,
  _swigc__p_FIX__PosMaintResult,
  _swigc__p_FIX__PosMaintRptID,
  _swigc__p_FIX__PosMaintRptRefID,
  _swigc__p_FIX__PosMaintStatus,
  _swigc__p_FIX__PosQtyStatus,
  _swigc__p_FIX__PosReqID,
  _swigc__p_FIX__PosReqResult,
  _swigc__p_FIX__PosReqStatus,
  _swigc__p_FIX__PosReqType,
  _swigc__p_FIX__PosTransType,
  _swigc__p_FIX__PosType,
  _swigc__p_FIX__PositionCurrency,
  _swigc__p_FIX__PositionEffect,
  _swigc__p_FIX__PositionLimit,
  _swigc__p_FIX__PossDupFlag,
  _swigc__p_FIX__PossResend,
  _swigc__p_FIX__PreTradeAnonymity,
  _swigc__p_FIX__PreallocMethod,
  _swigc__p_FIX__PrevClosePx,
  _swigc__p_FIX__PreviouslyReported,
  _swigc__p_FIX__Price,
  _swigc__p_FIX__Price2,
  _swigc__p_FIX__PriceDelta,
  _swigc__p_FIX__PriceImprovement,
  _swigc__p_FIX__PriceLimitType,
  _swigc__p_FIX__PriceProtectionScope,
  _swigc__p_FIX__PriceQuoteMethod,
  _swigc__p_FIX__PriceType,
  _swigc__p_FIX__PriceUnitOfMeasure,
  _swigc__p_FIX__PriceUnitOfMeasureQty,
  _swigc__p_FIX__PriorSettlPrice,
  _swigc__p_FIX__PriorSpreadIndicator,
  _swigc__p_FIX__PriorityIndicator,
  _swigc__p_FIX__PrivateQuote,
  _swigc__p_FIX__ProcessCode,
  _swigc__p_FIX__Product,
  _swigc__p_FIX__ProductComplex,
  _swigc__p_FIX__ProgPeriodInterval,
  _swigc__p_FIX__ProgRptReqs,
  _swigc__p_FIX__PublishTrdIndicator,
  _swigc__p_FIX__PutOrCall,
  _swigc__p_FIX__QTY,
  _swigc__p_FIX__QtyType,
  _swigc__p_FIX__Quantity,
  _swigc__p_FIX__QuantityDate,
  _swigc__p_FIX__QuantityType,
  _swigc__p_FIX__QuoteAckStatus,
  _swigc__p_FIX__QuoteCancelType,
  _swigc__p_FIX__QuoteCondition,
  _swigc__p_FIX__QuoteEntryID,
  _swigc__p_FIX__QuoteEntryRejectReason,
  _swigc__p_FIX__QuoteEntryStatus,
  _swigc__p_FIX__QuoteID,
  _swigc__p_FIX__QuoteMsgID,
  _swigc__p_FIX__QuotePriceType,
  _swigc__p_FIX__QuoteQualifier,
  _swigc__p_FIX__QuoteRejectReason,
  _swigc__p_FIX__QuoteReqID,
  _swigc__p_FIX__QuoteRequestRejectReason,
  _swigc__p_FIX__QuoteRequestType,
  _swigc__p_FIX__QuoteRespID,
  _swigc__p_FIX__QuoteRespType,
  _swigc__p_FIX__QuoteResponseLevel,
  _swigc__p_FIX__QuoteSetID,
  _swigc__p_FIX__QuoteSetValidUntilTime,
  _swigc__p_FIX__QuoteStatus,
  _swigc__p_FIX__QuoteStatusReqID,
  _swigc__p_FIX__QuoteType,
  _swigc__p_FIX__RFQReqID,
  _swigc__p_FIX__RateSource,
  _swigc__p_FIX__RateSourceType,
  _swigc__p_FIX__RatioQty,
  _swigc__p_FIX__RawData,
  _swigc__p_FIX__RawDataLength,
  _swigc__p_FIX__ReceivedDeptID,
  _swigc__p_FIX__RedemptionDate,
  _swigc__p_FIX__RefAllocID,
  _swigc__p_FIX__RefApplExtID,
  _swigc__p_FIX__RefApplID,
  _swigc__p_FIX__RefApplLastSeqNum,
  _swigc__p_FIX__RefApplReqID,
  _swigc__p_FIX__RefApplVerID,
  _swigc__p_FIX__RefCompID,
  _swigc__p_FIX__RefCstmApplVerID,
  _swigc__p_FIX__RefMsgType,
  _swigc__p_FIX__RefOrdIDReason,
  _swigc__p_FIX__RefOrderID,
  _swigc__p_FIX__RefOrderIDSource,
  _swigc__p_FIX__RefSeqNum,
  _swigc__p_FIX__RefSubID,
  _swigc__p_FIX__RefTagID,
  _swigc__p_FIX__ReferencePage,
  _swigc__p_FIX__RefreshIndicator,
  _swigc__p_FIX__RefreshQty,
  _swigc__p_FIX__RegistAcctType,
  _swigc__p_FIX__RegistDetls,
  _swigc__p_FIX__RegistDtls,
  _swigc__p_FIX__RegistEmail,
  _swigc__p_FIX__RegistID,
  _swigc__p_FIX__RegistRefID,
  _swigc__p_FIX__RegistRejReasonCode,
  _swigc__p_FIX__RegistRejReasonText,
  _swigc__p_FIX__RegistStatus,
  _swigc__p_FIX__RegistTransType,
  _swigc__p_FIX__RejectLogon,
  _swigc__p_FIX__RejectText,
  _swigc__p_FIX__RelSymTransactTime,
  _swigc__p_FIX__RelatdSym,
  _swigc__p_FIX__RelatedContextPartyID,
  _swigc__p_FIX__RelatedContextPartyIDSource,
  _swigc__p_FIX__RelatedContextPartyRole,
  _swigc__p_FIX__RelatedContextPartySubID,
  _swigc__p_FIX__RelatedContextPartySubIDType,
  _swigc__p_FIX__RelatedPartyAltID,
  _swigc__p_FIX__RelatedPartyAltIDSource,
  _swigc__p_FIX__RelatedPartyAltSubID,
  _swigc__p_FIX__RelatedPartyAltSubIDType,
  _swigc__p_FIX__RelatedPartyID,
  _swigc__p_FIX__RelatedPartyIDSource,
  _swigc__p_FIX__RelatedPartyRole,
  _swigc__p_FIX__RelatedPartySubID,
  _swigc__p_FIX__RelatedPartySubIDType,
  _swigc__p_FIX__RelationshipRiskCFICode,
  _swigc__p_FIX__RelationshipRiskCouponRate,
  _swigc__p_FIX__RelationshipRiskEncodedSecurityDesc,
  _swigc__p_FIX__RelationshipRiskEncodedSecurityDescLen,
  _swigc__p_FIX__RelationshipRiskFlexibleIndicator,
  _swigc__p_FIX__RelationshipRiskInstrumentMultiplier,
  _swigc__p_FIX__RelationshipRiskInstrumentOperator,
  _swigc__p_FIX__RelationshipRiskInstrumentSettlType,
  _swigc__p_FIX__RelationshipRiskLimitAmount,
  _swigc__p_FIX__RelationshipRiskLimitCurrency,
  _swigc__p_FIX__RelationshipRiskLimitPlatform,
  _swigc__p_FIX__RelationshipRiskLimitType,
  _swigc__p_FIX__RelationshipRiskMaturityMonthYear,
  _swigc__p_FIX__RelationshipRiskMaturityTime,
  _swigc__p_FIX__RelationshipRiskProduct,
  _swigc__p_FIX__RelationshipRiskProductComplex,
  _swigc__p_FIX__RelationshipRiskPutOrCall,
  _swigc__p_FIX__RelationshipRiskRestructuringType,
  _swigc__p_FIX__RelationshipRiskSecurityAltID,
  _swigc__p_FIX__RelationshipRiskSecurityAltIDSource,
  _swigc__p_FIX__RelationshipRiskSecurityDesc,
  _swigc__p_FIX__RelationshipRiskSecurityExchange,
  _swigc__p_FIX__RelationshipRiskSecurityGroup,
  _swigc__p_FIX__RelationshipRiskSecurityID,
  _swigc__p_FIX__RelationshipRiskSecurityIDSource,
  _swigc__p_FIX__RelationshipRiskSecuritySubType,
  _swigc__p_FIX__RelationshipRiskSecurityType,
  _swigc__p_FIX__RelationshipRiskSeniority,
  _swigc__p_FIX__RelationshipRiskSymbol,
  _swigc__p_FIX__RelationshipRiskSymbolSfx,
  _swigc__p_FIX__RelationshipRiskWarningLevelName,
  _swigc__p_FIX__RelationshipRiskWarningLevelPercent,
  _swigc__p_FIX__RepeatedTag,
  _swigc__p_FIX__RepeatingGroupCountMismatch,
  _swigc__p_FIX__RepoCollateralSecurityType,
  _swigc__p_FIX__ReportToExch,
  _swigc__p_FIX__ReportedPx,
  _swigc__p_FIX__ReportedPxDiff,
  _swigc__p_FIX__RepurchaseRate,
  _swigc__p_FIX__RepurchaseTerm,
  _swigc__p_FIX__RequestedPartyRole,
  _swigc__p_FIX__RequiredTagMissing,
  _swigc__p_FIX__ResetSeqNumFlag,
  _swigc__p_FIX__RespondentType,
  _swigc__p_FIX__ResponseDestination,
  _swigc__p_FIX__ResponseTransportType,
  _swigc__p_FIX__RestructuringType,
  _swigc__p_FIX__ReversalIndicator,
  _swigc__p_FIX__RiskCFICode,
  _swigc__p_FIX__RiskCouponRate,
  _swigc__p_FIX__RiskEncodedSecurityDesc,
  _swigc__p_FIX__RiskEncodedSecurityDescLen,
  _swigc__p_FIX__RiskFlexibleIndicator,
  _swigc__p_FIX__RiskFreeRate,
  _swigc__p_FIX__RiskInstrumentMultiplier,
  _swigc__p_FIX__RiskInstrumentOperator,
  _swigc__p_FIX__RiskInstrumentSettlType,
  _swigc__p_FIX__RiskLimitAmount,
  _swigc__p_FIX__RiskLimitCurrency,
  _swigc__p_FIX__RiskLimitPlatform,
  _swigc__p_FIX__RiskLimitType,
  _swigc__p_FIX__RiskMaturityMonthYear,
  _swigc__p_FIX__RiskMaturityTime,
  _swigc__p_FIX__RiskProduct,
  _swigc__p_FIX__RiskProductComplex,
  _swigc__p_FIX__RiskPutOrCall,
  _swigc__p_FIX__RiskRestructuringType,
  _swigc__p_FIX__RiskSecurityAltID,
  _swigc__p_FIX__RiskSecurityAltIDSource,
  _swigc__p_FIX__RiskSecurityDesc,
  _swigc__p_FIX__RiskSecurityExchange,
  _swigc__p_FIX__RiskSecurityGroup,
  _swigc__p_FIX__RiskSecurityID,
  _swigc__p_FIX__RiskSecurityIDSource,
  _swigc__p_FIX__RiskSecuritySubType,
  _swigc__p_FIX__RiskSecurityType,
  _swigc__p_FIX__RiskSeniority,
  _swigc__p_FIX__RiskSymbol,
  _swigc__p_FIX__RiskSymbolSfx,
  _swigc__p_FIX__RiskWarningLevelName,
  _swigc__p_FIX__RiskWarningLevelPercent,
  _swigc__p_FIX__RndPx,
  _swigc__p_FIX__RootPartyID,
  _swigc__p_FIX__RootPartyIDSource,
  _swigc__p_FIX__RootPartyRole,
  _swigc__p_FIX__RootPartySubID,
  _swigc__p_FIX__RootPartySubIDType,
  _swigc__p_FIX__RoundLot,
  _swigc__p_FIX__RoundingDirection,
  _swigc__p_FIX__RoundingModulus,
  _swigc__p_FIX__RoutingID,
  _swigc__p_FIX__RoutingType,
  _swigc__p_FIX__RptSeq,
  _swigc__p_FIX__RptSys,
  _swigc__p_FIX__Rule80A,
  _swigc__p_FIX__RuntimeError,
  _swigc__p_FIX__SEQNUM,
  _swigc__p_FIX__STRING,
  _swigc__p_FIX__Scope,
  _swigc__p_FIX__ScreenLog,
  _swigc__p_FIX__ScreenLogFactory,
  _swigc__p_FIX__SecDefStatus,
  _swigc__p_FIX__SecondaryAllocID,
  _swigc__p_FIX__SecondaryClOrdID,
  _swigc__p_FIX__SecondaryDisplayQty,
  _swigc__p_FIX__SecondaryExecID,
  _swigc__p_FIX__SecondaryFirmTradeID,
  _swigc__p_FIX__SecondaryHighLimitPrice,
  _swigc__p_FIX__SecondaryIndividualAllocID,
  _swigc__p_FIX__SecondaryLowLimitPrice,
  _swigc__p_FIX__SecondaryOrderID,
  _swigc__p_FIX__SecondaryPriceLimitType,
  _swigc__p_FIX__SecondaryTradeID,
  _swigc__p_FIX__SecondaryTradeReportID,
  _swigc__p_FIX__SecondaryTradeReportRefID,
  _swigc__p_FIX__SecondaryTradingReferencePrice,
  _swigc__p_FIX__SecondaryTrdType,
  _swigc__p_FIX__SecureData,
  _swigc__p_FIX__SecureDataLen,
  _swigc__p_FIX__SecurityAltID,
  _swigc__p_FIX__SecurityAltIDSource,
  _swigc__p_FIX__SecurityDesc,
  _swigc__p_FIX__SecurityExchange,
  _swigc__p_FIX__SecurityGroup,
  _swigc__p_FIX__SecurityID,
  _swigc__p_FIX__SecurityIDSource,
  _swigc__p_FIX__SecurityListDesc,
  _swigc__p_FIX__SecurityListID,
  _swigc__p_FIX__SecurityListRefID,
  _swigc__p_FIX__SecurityListRequestType,
  _swigc__p_FIX__SecurityListType,
  _swigc__p_FIX__SecurityListTypeSource,
  _swigc__p_FIX__SecurityReportID,
  _swigc__p_FIX__SecurityReqID,
  _swigc__p_FIX__SecurityRequestResult,
  _swigc__p_FIX__SecurityRequestType,
  _swigc__p_FIX__SecurityResponseID,
  _swigc__p_FIX__SecurityResponseType,
  _swigc__p_FIX__SecuritySettlAgentAcctName,
  _swigc__p_FIX__SecuritySettlAgentAcctNum,
  _swigc__p_FIX__SecuritySettlAgentCode,
  _swigc__p_FIX__SecuritySettlAgentContactName,
  _swigc__p_FIX__SecuritySettlAgentContactPhone,
  _swigc__p_FIX__SecuritySettlAgentName,
  _swigc__p_FIX__SecurityStatus,
  _swigc__p_FIX__SecurityStatusReqID,
  _swigc__p_FIX__SecuritySubType,
  _swigc__p_FIX__SecurityTradingEvent,
  _swigc__p_FIX__SecurityTradingStatus,
  _swigc__p_FIX__SecurityType,
  _swigc__p_FIX__SecurityUpdateAction,
  _swigc__p_FIX__SecurityXML,
  _swigc__p_FIX__SecurityXMLLen,
  _swigc__p_FIX__SecurityXMLSchema,
  _swigc__p_FIX__SellVolume,
  _swigc__p_FIX__SellerDays,
  _swigc__p_FIX__SenderCompID,
  _swigc__p_FIX__SenderLocationID,
  _swigc__p_FIX__SenderSubID,
  _swigc__p_FIX__SendingDate,
  _swigc__p_FIX__SendingTime,
  _swigc__p_FIX__Seniority,
  _swigc__p_FIX__Session,
  _swigc__p_FIX__SessionID,
  _swigc__p_FIX__SessionNotFound,
  _swigc__p_FIX__SessionRejectReason,
  _swigc__p_FIX__SessionSettings,
  _swigc__p_FIX__SessionStatus,
  _swigc__p_FIX__SettlBrkrCode,
  _swigc__p_FIX__SettlCurrAmt,
  _swigc__p_FIX__SettlCurrBidFxRate,
  _swigc__p_FIX__SettlCurrFxRate,
  _swigc__p_FIX__SettlCurrFxRateCalc,
  _swigc__p_FIX__SettlCurrOfferFxRate,
  _swigc__p_FIX__SettlCurrency,
  _swigc__p_FIX__SettlDate,
  _swigc__p_FIX__SettlDate2,
  _swigc__p_FIX__SettlDeliveryType,
  _swigc__p_FIX__SettlDepositoryCode,
  _swigc__p_FIX__SettlInstCode,
  _swigc__p_FIX__SettlInstID,
  _swigc__p_FIX__SettlInstMode,
  _swigc__p_FIX__SettlInstMsgID,
  _swigc__p_FIX__SettlInstRefID,
  _swigc__p_FIX__SettlInstReqID,
  _swigc__p_FIX__SettlInstReqRejCode,
  _swigc__p_FIX__SettlInstSource,
  _swigc__p_FIX__SettlInstTransType,
  _swigc__p_FIX__SettlLocation,
  _swigc__p_FIX__SettlMethod,
  _swigc__p_FIX__SettlObligID,
  _swigc__p_FIX__SettlObligMode,
  _swigc__p_FIX__SettlObligMsgID,
  _swigc__p_FIX__SettlObligRefID,
  _swigc__p_FIX__SettlObligSource,
  _swigc__p_FIX__SettlObligTransType,
  _swigc__p_FIX__SettlPartyID,
  _swigc__p_FIX__SettlPartyIDSource,
  _swigc__p_FIX__SettlPartyRole,
  _swigc__p_FIX__SettlPartySubID,
  _swigc__p_FIX__SettlPartySubIDType,
  _swigc__p_FIX__SettlPrice,
  _swigc__p_FIX__SettlPriceType,
  _swigc__p_FIX__SettlSessID,
  _swigc__p_FIX__SettlSessSubID,
  _swigc__p_FIX__SettlType,
  _swigc__p_FIX__SettleOnOpenFlag,
  _swigc__p_FIX__SettlementCycleNo,
  _swigc__p_FIX__SettlmntTyp,
  _swigc__p_FIX__SharedCommission,
  _swigc__p_FIX__Shares,
  _swigc__p_FIX__ShortQty,
  _swigc__p_FIX__ShortSaleReason,
  _swigc__p_FIX__Side,
  _swigc__p_FIX__SideComplianceID,
  _swigc__p_FIX__SideCurrency,
  _swigc__p_FIX__SideExecID,
  _swigc__p_FIX__SideFillStationCd,
  _swigc__p_FIX__SideGrossTradeAmt,
  _swigc__p_FIX__SideLastQty,
  _swigc__p_FIX__SideLiquidityInd,
  _swigc__p_FIX__SideMultiLegReportingType,
  _swigc__p_FIX__SideQty,
  _swigc__p_FIX__SideReasonCd,
  _swigc__p_FIX__SideSettlCurrency,
  _swigc__p_FIX__SideTimeInForce,
  _swigc__p_FIX__SideTradeReportID,
  _swigc__p_FIX__SideTrdRegTimestamp,
  _swigc__p_FIX__SideTrdRegTimestampSrc,
  _swigc__p_FIX__SideTrdRegTimestampType,
  _swigc__p_FIX__SideTrdSubTyp,
  _swigc__p_FIX__SideValue1,
  _swigc__p_FIX__SideValue2,
  _swigc__p_FIX__SideValueInd,
  _swigc__p_FIX__Signature,
  _swigc__p_FIX__SignatureLength,
  _swigc__p_FIX__SocketAcceptor,
  _swigc__p_FIX__SocketCloseFailed,
  _swigc__p_FIX__SocketException,
  _swigc__p_FIX__SocketInitiator,
  _swigc__p_FIX__SocketRecvFailed,
  _swigc__p_FIX__SocketSendFailed,
  _swigc__p_FIX__SolicitedFlag,
  _swigc__p_FIX__Spread,
  _swigc__p_FIX__SpreadToBenchmark,
  _swigc__p_FIX__StandInstDbID,
  _swigc__p_FIX__StandInstDbName,
  _swigc__p_FIX__StandInstDbType,
  _swigc__p_FIX__StartCash,
  _swigc__p_FIX__StartDate,
  _swigc__p_FIX__StartMaturityMonthYear,
  _swigc__p_FIX__StartStrikePxRange,
  _swigc__p_FIX__StartTickPriceRange,
  _swigc__p_FIX__StateOrProvinceOfIssue,
  _swigc__p_FIX__StatsType,
  _swigc__p_FIX__StatusText,
  _swigc__p_FIX__StatusValue,
  _swigc__p_FIX__StipulationType,
  _swigc__p_FIX__StipulationValue,
  _swigc__p_FIX__StopPx,
  _swigc__p_FIX__StrategyParameterName,
  _swigc__p_FIX__StrategyParameterType,
  _swigc__p_FIX__StrategyParameterValue,
  _swigc__p_FIX__StreamAsgnAckType,
  _swigc__p_FIX__StreamAsgnRejReason,
  _swigc__p_FIX__StreamAsgnReqID,
  _swigc__p_FIX__StreamAsgnReqType,
  _swigc__p_FIX__StreamAsgnRptID,
  _swigc__p_FIX__StreamAsgnType,
  _swigc__p_FIX__StrikeCurrency,
  _swigc__p_FIX__StrikeExerciseStyle,
  _swigc__p_FIX__StrikeIncrement,
  _swigc__p_FIX__StrikeMultiplier,
  _swigc__p_FIX__StrikePrice,
  _swigc__p_FIX__StrikePriceBoundaryMethod,
  _swigc__p_FIX__StrikePriceBoundaryPrecision,
  _swigc__p_FIX__StrikePriceDeterminationMethod,
  _swigc__p_FIX__StrikeRuleID,
  _swigc__p_FIX__StrikeTime,
  _swigc__p_FIX__StrikeValue,
  _swigc__p_FIX__StringField,
  _swigc__p_FIX__Subject,
  _swigc__p_FIX__SubscriptionRequestType,
  _swigc__p_FIX__SwapPoints,
  _swigc__p_FIX__Symbol,
  _swigc__p_FIX__SymbolSfx,
  _swigc__p_FIX__SynchronizedApplication,
  _swigc__p_FIX__TYPE__Type,
  _swigc__p_FIX__TZTIMEONLY,
  _swigc__p_FIX__TZTIMESTAMP,
  _swigc__p_FIX__TZTransactTime,
  _swigc__p_FIX__TagNotDefinedForMessage,
  _swigc__p_FIX__TagOutOfOrder,
  _swigc__p_FIX__TargetCompID,
  _swigc__p_FIX__TargetLocationID,
  _swigc__p_FIX__TargetPartyID,
  _swigc__p_FIX__TargetPartyIDSource,
  _swigc__p_FIX__TargetPartyRole,
  _swigc__p_FIX__TargetStrategy,
  _swigc__p_FIX__TargetStrategyParameters,
  _swigc__p_FIX__TargetStrategyPerformance,
  _swigc__p_FIX__TargetSubID,
  _swigc__p_FIX__TaxAdvantageType,
  _swigc__p_FIX__TerminationType,
  _swigc__p_FIX__TestMessageIndicator,
  _swigc__p_FIX__TestReqID,
  _swigc__p_FIX__Text,
  _swigc__p_FIX__ThresholdAmount,
  _swigc__p_FIX__TickDirection,
  _swigc__p_FIX__TickIncrement,
  _swigc__p_FIX__TickRuleType,
  _swigc__p_FIX__TierCode,
  _swigc__p_FIX__TimeBracket,
  _swigc__p_FIX__TimeInForce,
  _swigc__p_FIX__TimeToExpiration,
  _swigc__p_FIX__TimeUnit,
  _swigc__p_FIX__TotNoAccQuotes,
  _swigc__p_FIX__TotNoAllocs,
  _swigc__p_FIX__TotNoCxldQuotes,
  _swigc__p_FIX__TotNoFills,
  _swigc__p_FIX__TotNoOrders,
  _swigc__p_FIX__TotNoPartyList,
  _swigc__p_FIX__TotNoQuoteEntries,
  _swigc__p_FIX__TotNoRejQuotes,
  _swigc__p_FIX__TotNoRelatedSym,
  _swigc__p_FIX__TotNoSecurityTypes,
  _swigc__p_FIX__TotNoStrikes,
  _swigc__p_FIX__TotNumAssignmentReports,
  _swigc__p_FIX__TotNumReports,
  _swigc__p_FIX__TotNumTradeReports,
  _swigc__p_FIX__TotQuoteEntries,
  _swigc__p_FIX__TotalAccruedInterestAmt,
  _swigc__p_FIX__TotalAffectedOrders,
  _swigc__p_FIX__TotalNetValue,
  _swigc__p_FIX__TotalNumPosReports,
  _swigc__p_FIX__TotalNumSecurities,
  _swigc__p_FIX__TotalNumSecurityTypes,
  _swigc__p_FIX__TotalTakedown,
  _swigc__p_FIX__TotalVolumeTraded,
  _swigc__p_FIX__TotalVolumeTradedDate,
  _swigc__p_FIX__TotalVolumeTradedTime,
  _swigc__p_FIX__TradSesCloseTime,
  _swigc__p_FIX__TradSesEndTime,
  _swigc__p_FIX__TradSesEvent,
  _swigc__p_FIX__TradSesMethod,
  _swigc__p_FIX__TradSesMode,
  _swigc__p_FIX__TradSesOpenTime,
  _swigc__p_FIX__TradSesPreCloseTime,
  _swigc__p_FIX__TradSesReqID,
  _swigc__p_FIX__TradSesStartTime,
  _swigc__p_FIX__TradSesStatus,
  _swigc__p_FIX__TradSesStatusRejReason,
  _swigc__p_FIX__TradSesUpdateAction,
  _swigc__p_FIX__TradeAllocIndicator,
  _swigc__p_FIX__TradeCondition,
  _swigc__p_FIX__TradeDate,
  _swigc__p_FIX__TradeHandlingInstr,
  _swigc__p_FIX__TradeID,
  _swigc__p_FIX__TradeInputDevice,
  _swigc__p_FIX__TradeInputSource,
  _swigc__p_FIX__TradeLegRefID,
  _swigc__p_FIX__TradeLinkID,
  _swigc__p_FIX__TradeOriginationDate,
  _swigc__p_FIX__TradePublishIndicator,
  _swigc__p_FIX__TradeReportID,
  _swigc__p_FIX__TradeReportRefID,
  _swigc__p_FIX__TradeReportRejectReason,
  _swigc__p_FIX__TradeReportTransType,
  _swigc__p_FIX__TradeReportType,
  _swigc__p_FIX__TradeRequestID,
  _swigc__p_FIX__TradeRequestResult,
  _swigc__p_FIX__TradeRequestStatus,
  _swigc__p_FIX__TradeRequestType,
  _swigc__p_FIX__TradeType,
  _swigc__p_FIX__TradeVolume,
  _swigc__p_FIX__TradedFlatSwitch,
  _swigc__p_FIX__TradingCurrency,
  _swigc__p_FIX__TradingReferencePrice,
  _swigc__p_FIX__TradingSessionDesc,
  _swigc__p_FIX__TradingSessionID,
  _swigc__p_FIX__TradingSessionSubID,
  _swigc__p_FIX__TransBkdTime,
  _swigc__p_FIX__TransactTime,
  _swigc__p_FIX__TransferReason,
  _swigc__p_FIX__TrdMatchID,
  _swigc__p_FIX__TrdRegTimestamp,
  _swigc__p_FIX__TrdRegTimestampOrigin,
  _swigc__p_FIX__TrdRegTimestampType,
  _swigc__p_FIX__TrdRepIndicator,
  _swigc__p_FIX__TrdRepPartyRole,
  _swigc__p_FIX__TrdRptStatus,
  _swigc__p_FIX__TrdSubType,
  _swigc__p_FIX__TrdType,
  _swigc__p_FIX__TriggerAction,
  _swigc__p_FIX__TriggerNewPrice,
  _swigc__p_FIX__TriggerNewQty,
  _swigc__p_FIX__TriggerOrderType,
  _swigc__p_FIX__TriggerPrice,
  _swigc__p_FIX__TriggerPriceDirection,
  _swigc__p_FIX__TriggerPriceType,
  _swigc__p_FIX__TriggerPriceTypeScope,
  _swigc__p_FIX__TriggerSecurityDesc,
  _swigc__p_FIX__TriggerSecurityID,
  _swigc__p_FIX__TriggerSecurityIDSource,
  _swigc__p_FIX__TriggerSymbol,
  _swigc__p_FIX__TriggerTradingSessionID,
  _swigc__p_FIX__TriggerTradingSessionSubID,
  _swigc__p_FIX__TriggerType,
  _swigc__p_FIX__URLLink,
  _swigc__p_FIX__UTCDATEONLY,
  _swigc__p_FIX__UTCTIMEONLY,
  _swigc__p_FIX__UTCTIMESTAMP,
  _swigc__p_FIX__UnderlyingAdjustedQuantity,
  _swigc__p_FIX__UnderlyingAllocationPercent,
  _swigc__p_FIX__UnderlyingAttachmentPoint,
  _swigc__p_FIX__UnderlyingCFICode,
  _swigc__p_FIX__UnderlyingCPProgram,
  _swigc__p_FIX__UnderlyingCPRegType,
  _swigc__p_FIX__UnderlyingCapValue,
  _swigc__p_FIX__UnderlyingCashAmount,
  _swigc__p_FIX__UnderlyingCashType,
  _swigc__p_FIX__UnderlyingCollectAmount,
  _swigc__p_FIX__UnderlyingContractMultiplier,
  _swigc__p_FIX__UnderlyingContractMultiplierUnit,
  _swigc__p_FIX__UnderlyingCountryOfIssue,
  _swigc__p_FIX__UnderlyingCouponPaymentDate,
  _swigc__p_FIX__UnderlyingCouponRate,
  _swigc__p_FIX__UnderlyingCreditRating,
  _swigc__p_FIX__UnderlyingCurrency,
  _swigc__p_FIX__UnderlyingCurrentValue,
  _swigc__p_FIX__UnderlyingDeliveryAmount,
  _swigc__p_FIX__UnderlyingDetachmentPoint,
  _swigc__p_FIX__UnderlyingDirtyPrice,
  _swigc__p_FIX__UnderlyingEndPrice,
  _swigc__p_FIX__UnderlyingEndValue,
  _swigc__p_FIX__UnderlyingExerciseStyle,
  _swigc__p_FIX__UnderlyingFXRate,
  _swigc__p_FIX__UnderlyingFXRateCalc,
  _swigc__p_FIX__UnderlyingFactor,
  _swigc__p_FIX__UnderlyingFlowScheduleType,
  _swigc__p_FIX__UnderlyingIDSource,
  _swigc__p_FIX__UnderlyingInstrRegistry,
  _swigc__p_FIX__UnderlyingInstrumentPartyID,
  _swigc__p_FIX__UnderlyingInstrumentPartyIDSource,
  _swigc__p_FIX__UnderlyingInstrumentPartyRole,
  _swigc__p_FIX__UnderlyingInstrumentPartySubID,
  _swigc__p_FIX__UnderlyingInstrumentPartySubIDType,
  _swigc__p_FIX__UnderlyingIssueDate,
  _swigc__p_FIX__UnderlyingIssuer,
  _swigc__p_FIX__UnderlyingLastPx,
  _swigc__p_FIX__UnderlyingLastQty,
  _swigc__p_FIX__UnderlyingLegCFICode,
  _swigc__p_FIX__UnderlyingLegMaturityDate,
  _swigc__p_FIX__UnderlyingLegMaturityMonthYear,
  _swigc__p_FIX__UnderlyingLegMaturityTime,
  _swigc__p_FIX__UnderlyingLegOptAttribute,
  _swigc__p_FIX__UnderlyingLegPutOrCall,
  _swigc__p_FIX__UnderlyingLegSecurityAltID,
  _swigc__p_FIX__UnderlyingLegSecurityAltIDSource,
  _swigc__p_FIX__UnderlyingLegSecurityDesc,
  _swigc__p_FIX__UnderlyingLegSecurityExchange,
  _swigc__p_FIX__UnderlyingLegSecurityID,
  _swigc__p_FIX__UnderlyingLegSecurityIDSource,
  _swigc__p_FIX__UnderlyingLegSecuritySubType,
  _swigc__p_FIX__UnderlyingLegSecurityType,
  _swigc__p_FIX__UnderlyingLegStrikePrice,
  _swigc__p_FIX__UnderlyingLegSymbol,
  _swigc__p_FIX__UnderlyingLegSymbolSfx,
  _swigc__p_FIX__UnderlyingLocaleOfIssue,
  _swigc__p_FIX__UnderlyingMaturityDate,
  _swigc__p_FIX__UnderlyingMaturityDay,
  _swigc__p_FIX__UnderlyingMaturityMonthYear,
  _swigc__p_FIX__UnderlyingMaturityTime,
  _swigc__p_FIX__UnderlyingNotionalPercentageOutstanding,
  _swigc__p_FIX__UnderlyingOptAttribute,
  _swigc__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding,
  _swigc__p_FIX__UnderlyingPayAmount,
  _swigc__p_FIX__UnderlyingPriceDeterminationMethod,
  _swigc__p_FIX__UnderlyingPriceUnitOfMeasure,
  _swigc__p_FIX__UnderlyingPriceUnitOfMeasureQty,
  _swigc__p_FIX__UnderlyingProduct,
  _swigc__p_FIX__UnderlyingPutOrCall,
  _swigc__p_FIX__UnderlyingPx,
  _swigc__p_FIX__UnderlyingQty,
  _swigc__p_FIX__UnderlyingRedemptionDate,
  _swigc__p_FIX__UnderlyingRepoCollateralSecurityType,
  _swigc__p_FIX__UnderlyingRepurchaseRate,
  _swigc__p_FIX__UnderlyingRepurchaseTerm,
  _swigc__p_FIX__UnderlyingRestructuringType,
  _swigc__p_FIX__UnderlyingSecurityAltID,
  _swigc__p_FIX__UnderlyingSecurityAltIDSource,
  _swigc__p_FIX__UnderlyingSecurityDesc,
  _swigc__p_FIX__UnderlyingSecurityExchange,
  _swigc__p_FIX__UnderlyingSecurityID,
  _swigc__p_FIX__UnderlyingSecurityIDSource,
  _swigc__p_FIX__UnderlyingSecuritySubType,
  _swigc__p_FIX__UnderlyingSecurityType,
  _swigc__p_FIX__UnderlyingSeniority,
  _swigc__p_FIX__UnderlyingSettlMethod,
  _swigc__p_FIX__UnderlyingSettlPrice,
  _swigc__p_FIX__UnderlyingSettlPriceType,
  _swigc__p_FIX__UnderlyingSettlementDate,
  _swigc__p_FIX__UnderlyingSettlementStatus,
  _swigc__p_FIX__UnderlyingSettlementType,
  _swigc__p_FIX__UnderlyingStartValue,
  _swigc__p_FIX__UnderlyingStateOrProvinceOfIssue,
  _swigc__p_FIX__UnderlyingStipType,
  _swigc__p_FIX__UnderlyingStipValue,
  _swigc__p_FIX__UnderlyingStrikeCurrency,
  _swigc__p_FIX__UnderlyingStrikePrice,
  _swigc__p_FIX__UnderlyingSymbol,
  _swigc__p_FIX__UnderlyingSymbolSfx,
  _swigc__p_FIX__UnderlyingTimeUnit,
  _swigc__p_FIX__UnderlyingTradingSessionID,
  _swigc__p_FIX__UnderlyingTradingSessionSubID,
  _swigc__p_FIX__UnderlyingUnitOfMeasure,
  _swigc__p_FIX__UnderlyingUnitOfMeasureQty,
  _swigc__p_FIX__UndlyInstrumentPartyID,
  _swigc__p_FIX__UndlyInstrumentPartyIDSource,
  _swigc__p_FIX__UndlyInstrumentPartyRole,
  _swigc__p_FIX__UndlyInstrumentPartySubID,
  _swigc__p_FIX__UndlyInstrumentPartySubIDType,
  _swigc__p_FIX__UnitOfMeasure,
  _swigc__p_FIX__UnitOfMeasureQty,
  _swigc__p_FIX__UnsolicitedIndicator,
  _swigc__p_FIX__UnsupportedMessageType,
  _swigc__p_FIX__UnsupportedVersion,
  _swigc__p_FIX__Urgency,
  _swigc__p_FIX__UserRequestID,
  _swigc__p_FIX__UserRequestType,
  _swigc__p_FIX__UserStatus,
  _swigc__p_FIX__UserStatusText,
  _swigc__p_FIX__Username,
  _swigc__p_FIX__UtcDateField,
  _swigc__p_FIX__UtcTimeOnlyField,
  _swigc__p_FIX__UtcTimeStampField,
  _swigc__p_FIX__ValidUntilTime,
  _swigc__p_FIX__ValuationMethod,
  _swigc__p_FIX__ValueOfFutures,
  _swigc__p_FIX__VenueType,
  _swigc__p_FIX__Volatility,
  _swigc__p_FIX__WaveNo,
  _swigc__p_FIX__WorkingIndicator,
  _swigc__p_FIX__WtAverageLiquidity,
  _swigc__p_FIX__XMLDATA,
  _swigc__p_FIX__XmlData,
  _swigc__p_FIX__XmlDataLen,
  _swigc__p_FIX__Yield,
  _swigc__p_FIX__YieldCalcDate,
  _swigc__p_FIX__YieldRedemptionDate,
  _swigc__p_FIX__YieldRedemptionPrice,
  _swigc__p_FIX__YieldRedemptionPriceType,
  _swigc__p_FIX__YieldType,
  _swigc__p_Fields,
  _swigc__p_Group,
  _swigc__p_Groups,
  _swigc__p_IntArray,
  _swigc__p_IntField,
  _swigc__p_Log,
  _swigc__p_LogFactory,
  _swigc__p_MessageStore,
  _swigc__p_MessageStoreFactory,
  _swigc__p_MsgType,
  _swigc__p_Mutex,
  _swigc__p_Responder,
  _swigc__p_SessionID,
  _swigc__p_StringField,
  _swigc__p_TimeRange,
  _swigc__p_UtcDate,
  _swigc__p_UtcDateField,
  _swigc__p_UtcTimeOnly,
  _swigc__p_UtcTimeStamp,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_const_iterator,
  _swigc__p_g_const_iterator,
  _swigc__p_g_iterator,
  _swigc__p_int,
  _swigc__p_iterator,
  _swigc__p_message_order,
  _swigc__p_p_FIX__DataDictionary,
  _swigc__p_std__istream,
  _swigc__p_std__ostream,
  _swigc__p_std__setTFIX__SessionID_t,
  _swigc__p_std__string,
  _swigc__p_std__string__size_type,
  _swigc__p_std__vectorTstd__string_t,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic 
 * memory is used. Also, since swig_type_info structures store pointers to 
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization. 
 * The idea is that swig generates all the structures that are needed. 
 * The runtime then collects these partially filled structures. 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned staticly to an initial 
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it 
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded. 
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the 
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int found;

  clientdata = clientdata;

  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
  }

  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);

    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }

  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
  
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif

    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
	type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }

    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
    
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
	if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
	  cast->type = ret;
	  ret = 0;
	} else {
	  /* Check for casting already in the list */
	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
	  if (!ocast) ret = 0;
	}
      }

      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;

#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
  printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;

  if (init_run) return;
  init_run = 1;

  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

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


#ifdef __cplusplus
extern "C"
#endif
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();
  
  cIntArray.klass = rb_define_class_under(mQuickfix, "IntArray", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_IntArray, (void *) &cIntArray);
  rb_define_alloc_func(cIntArray.klass, _wrap_IntArray_allocate);
  rb_define_method(cIntArray.klass, "initialize", VALUEFUNC(_wrap_new_IntArray), -1);
  rb_define_method(cIntArray.klass, "[]", VALUEFUNC(_wrap_IntArray___getitem__), -1);
  rb_define_method(cIntArray.klass, "[]=", VALUEFUNC(_wrap_IntArray___setitem__), -1);
  rb_define_method(cIntArray.klass, "cast", VALUEFUNC(_wrap_IntArray_cast), -1);
  rb_define_singleton_method(cIntArray.klass, "frompointer", VALUEFUNC(_wrap_IntArray_frompointer), -1);
  cIntArray.mark = 0;
  cIntArray.destroy = (void (*)(void *)) free_IntArray;
  cIntArray.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
  
  
  cException.klass = rb_define_class_under(mQuickfix, "Exception", rb_eRuntimeError);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Exception, (void *) &cException);
  rb_define_alloc_func(cException.klass, _wrap_Exception_allocate);
  rb_define_method(cException.klass, "initialize", VALUEFUNC(_wrap_new_Exception), -1);
  rb_define_method(cException.klass, "type=", VALUEFUNC(_wrap_Exception_type_set), -1);
  rb_define_method(cException.klass, "type", VALUEFUNC(_wrap_Exception_type_get), -1);
  rb_define_method(cException.klass, "detail=", VALUEFUNC(_wrap_Exception_detail_set), -1);
  rb_define_method(cException.klass, "detail", VALUEFUNC(_wrap_Exception_detail_get), -1);
  rb_define_method(cException.klass, "to_s", VALUEFUNC(_wrap_Exception___str__), -1);
  cException.mark = 0;
  cException.destroy = (void (*)(void *)) free_FIX_Exception;
  cException.trackObjects = 0;
  
  cDataDictionaryNotFound.klass = rb_define_class_under(mQuickfix, "DataDictionaryNotFound", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DataDictionaryNotFound, (void *) &cDataDictionaryNotFound);
  rb_define_alloc_func(cDataDictionaryNotFound.klass, _wrap_DataDictionaryNotFound_allocate);
  rb_define_method(cDataDictionaryNotFound.klass, "initialize", VALUEFUNC(_wrap_new_DataDictionaryNotFound), -1);
  rb_define_method(cDataDictionaryNotFound.klass, "version=", VALUEFUNC(_wrap_DataDictionaryNotFound_version_set), -1);
  rb_define_method(cDataDictionaryNotFound.klass, "version", VALUEFUNC(_wrap_DataDictionaryNotFound_version_get), -1);
  cDataDictionaryNotFound.mark = 0;
  cDataDictionaryNotFound.destroy = (void (*)(void *)) free_FIX_DataDictionaryNotFound;
  cDataDictionaryNotFound.trackObjects = 0;
  
  cFieldNotFound.klass = rb_define_class_under(mQuickfix, "FieldNotFound", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldNotFound, (void *) &cFieldNotFound);
  rb_define_alloc_func(cFieldNotFound.klass, _wrap_FieldNotFound_allocate);
  rb_define_method(cFieldNotFound.klass, "initialize", VALUEFUNC(_wrap_new_FieldNotFound), -1);
  rb_define_method(cFieldNotFound.klass, "field=", VALUEFUNC(_wrap_FieldNotFound_field_set), -1);
  rb_define_method(cFieldNotFound.klass, "field", VALUEFUNC(_wrap_FieldNotFound_field_get), -1);
  cFieldNotFound.mark = 0;
  cFieldNotFound.destroy = (void (*)(void *)) free_FIX_FieldNotFound;
  cFieldNotFound.trackObjects = 0;
  
  cFieldConvertError.klass = rb_define_class_under(mQuickfix, "FieldConvertError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldConvertError, (void *) &cFieldConvertError);
  rb_define_alloc_func(cFieldConvertError.klass, _wrap_FieldConvertError_allocate);
  rb_define_method(cFieldConvertError.klass, "initialize", VALUEFUNC(_wrap_new_FieldConvertError), -1);
  cFieldConvertError.mark = 0;
  cFieldConvertError.destroy = (void (*)(void *)) free_FIX_FieldConvertError;
  cFieldConvertError.trackObjects = 0;
  
  cMessageParseError.klass = rb_define_class_under(mQuickfix, "MessageParseError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageParseError, (void *) &cMessageParseError);
  rb_define_alloc_func(cMessageParseError.klass, _wrap_MessageParseError_allocate);
  rb_define_method(cMessageParseError.klass, "initialize", VALUEFUNC(_wrap_new_MessageParseError), -1);
  cMessageParseError.mark = 0;
  cMessageParseError.destroy = (void (*)(void *)) free_FIX_MessageParseError;
  cMessageParseError.trackObjects = 0;
  
  cInvalidMessage.klass = rb_define_class_under(mQuickfix, "InvalidMessage", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvalidMessage, (void *) &cInvalidMessage);
  rb_define_alloc_func(cInvalidMessage.klass, _wrap_InvalidMessage_allocate);
  rb_define_method(cInvalidMessage.klass, "initialize", VALUEFUNC(_wrap_new_InvalidMessage), -1);
  cInvalidMessage.mark = 0;
  cInvalidMessage.destroy = (void (*)(void *)) free_FIX_InvalidMessage;
  cInvalidMessage.trackObjects = 0;
  
  cConfigError.klass = rb_define_class_under(mQuickfix, "ConfigError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfigError, (void *) &cConfigError);
  rb_define_alloc_func(cConfigError.klass, _wrap_ConfigError_allocate);
  rb_define_method(cConfigError.klass, "initialize", VALUEFUNC(_wrap_new_ConfigError), -1);
  cConfigError.mark = 0;
  cConfigError.destroy = (void (*)(void *)) free_FIX_ConfigError;
  cConfigError.trackObjects = 0;
  
  cRuntimeError.klass = rb_define_class_under(mQuickfix, "RuntimeError", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RuntimeError, (void *) &cRuntimeError);
  rb_define_alloc_func(cRuntimeError.klass, _wrap_RuntimeError_allocate);
  rb_define_method(cRuntimeError.klass, "initialize", VALUEFUNC(_wrap_new_RuntimeError), -1);
  cRuntimeError.mark = 0;
  cRuntimeError.destroy = (void (*)(void *)) free_FIX_RuntimeError;
  cRuntimeError.trackObjects = 0;
  
  cInvalidTagNumber.klass = rb_define_class_under(mQuickfix, "InvalidTagNumber", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvalidTagNumber, (void *) &cInvalidTagNumber);
  rb_define_alloc_func(cInvalidTagNumber.klass, _wrap_InvalidTagNumber_allocate);
  rb_define_method(cInvalidTagNumber.klass, "initialize", VALUEFUNC(_wrap_new_InvalidTagNumber), -1);
  rb_define_method(cInvalidTagNumber.klass, "field=", VALUEFUNC(_wrap_InvalidTagNumber_field_set), -1);
  rb_define_method(cInvalidTagNumber.klass, "field", VALUEFUNC(_wrap_InvalidTagNumber_field_get), -1);
  cInvalidTagNumber.mark = 0;
  cInvalidTagNumber.destroy = (void (*)(void *)) free_FIX_InvalidTagNumber;
  cInvalidTagNumber.trackObjects = 0;
  
  cRequiredTagMissing.klass = rb_define_class_under(mQuickfix, "RequiredTagMissing", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RequiredTagMissing, (void *) &cRequiredTagMissing);
  rb_define_alloc_func(cRequiredTagMissing.klass, _wrap_RequiredTagMissing_allocate);
  rb_define_method(cRequiredTagMissing.klass, "initialize", VALUEFUNC(_wrap_new_RequiredTagMissing), -1);
  rb_define_method(cRequiredTagMissing.klass, "field=", VALUEFUNC(_wrap_RequiredTagMissing_field_set), -1);
  rb_define_method(cRequiredTagMissing.klass, "field", VALUEFUNC(_wrap_RequiredTagMissing_field_get), -1);
  cRequiredTagMissing.mark = 0;
  cRequiredTagMissing.destroy = (void (*)(void *)) free_FIX_RequiredTagMissing;
  cRequiredTagMissing.trackObjects = 0;
  
  cTagNotDefinedForMessage.klass = rb_define_class_under(mQuickfix, "TagNotDefinedForMessage", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TagNotDefinedForMessage, (void *) &cTagNotDefinedForMessage);
  rb_define_alloc_func(cTagNotDefinedForMessage.klass, _wrap_TagNotDefinedForMessage_allocate);
  rb_define_method(cTagNotDefinedForMessage.klass, "initialize", VALUEFUNC(_wrap_new_TagNotDefinedForMessage), -1);
  rb_define_method(cTagNotDefinedForMessage.klass, "field=", VALUEFUNC(_wrap_TagNotDefinedForMessage_field_set), -1);
  rb_define_method(cTagNotDefinedForMessage.klass, "field", VALUEFUNC(_wrap_TagNotDefinedForMessage_field_get), -1);
  cTagNotDefinedForMessage.mark = 0;
  cTagNotDefinedForMessage.destroy = (void (*)(void *)) free_FIX_TagNotDefinedForMessage;
  cTagNotDefinedForMessage.trackObjects = 0;
  
  cNoTagValue.klass = rb_define_class_under(mQuickfix, "NoTagValue", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTagValue, (void *) &cNoTagValue);
  rb_define_alloc_func(cNoTagValue.klass, _wrap_NoTagValue_allocate);
  rb_define_method(cNoTagValue.klass, "initialize", VALUEFUNC(_wrap_new_NoTagValue), -1);
  rb_define_method(cNoTagValue.klass, "field=", VALUEFUNC(_wrap_NoTagValue_field_set), -1);
  rb_define_method(cNoTagValue.klass, "field", VALUEFUNC(_wrap_NoTagValue_field_get), -1);
  cNoTagValue.mark = 0;
  cNoTagValue.destroy = (void (*)(void *)) free_FIX_NoTagValue;
  cNoTagValue.trackObjects = 0;
  
  cIncorrectTagValue.klass = rb_define_class_under(mQuickfix, "IncorrectTagValue", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncorrectTagValue, (void *) &cIncorrectTagValue);
  rb_define_alloc_func(cIncorrectTagValue.klass, _wrap_IncorrectTagValue_allocate);
  rb_define_method(cIncorrectTagValue.klass, "initialize", VALUEFUNC(_wrap_new_IncorrectTagValue), -1);
  rb_define_method(cIncorrectTagValue.klass, "field=", VALUEFUNC(_wrap_IncorrectTagValue_field_set), -1);
  rb_define_method(cIncorrectTagValue.klass, "field", VALUEFUNC(_wrap_IncorrectTagValue_field_get), -1);
  cIncorrectTagValue.mark = 0;
  cIncorrectTagValue.destroy = (void (*)(void *)) free_FIX_IncorrectTagValue;
  cIncorrectTagValue.trackObjects = 0;
  
  cIncorrectDataFormat.klass = rb_define_class_under(mQuickfix, "IncorrectDataFormat", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncorrectDataFormat, (void *) &cIncorrectDataFormat);
  rb_define_alloc_func(cIncorrectDataFormat.klass, _wrap_IncorrectDataFormat_allocate);
  rb_define_method(cIncorrectDataFormat.klass, "initialize", VALUEFUNC(_wrap_new_IncorrectDataFormat), -1);
  rb_define_method(cIncorrectDataFormat.klass, "field=", VALUEFUNC(_wrap_IncorrectDataFormat_field_set), -1);
  rb_define_method(cIncorrectDataFormat.klass, "field", VALUEFUNC(_wrap_IncorrectDataFormat_field_get), -1);
  cIncorrectDataFormat.mark = 0;
  cIncorrectDataFormat.destroy = (void (*)(void *)) free_FIX_IncorrectDataFormat;
  cIncorrectDataFormat.trackObjects = 0;
  
  cIncorrectMessageStructure.klass = rb_define_class_under(mQuickfix, "IncorrectMessageStructure", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncorrectMessageStructure, (void *) &cIncorrectMessageStructure);
  rb_define_alloc_func(cIncorrectMessageStructure.klass, _wrap_IncorrectMessageStructure_allocate);
  rb_define_method(cIncorrectMessageStructure.klass, "initialize", VALUEFUNC(_wrap_new_IncorrectMessageStructure), -1);
  cIncorrectMessageStructure.mark = 0;
  cIncorrectMessageStructure.destroy = (void (*)(void *)) free_FIX_IncorrectMessageStructure;
  cIncorrectMessageStructure.trackObjects = 0;
  
  cDuplicateFieldNumber.klass = rb_define_class_under(mQuickfix, "DuplicateFieldNumber", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DuplicateFieldNumber, (void *) &cDuplicateFieldNumber);
  rb_define_alloc_func(cDuplicateFieldNumber.klass, _wrap_DuplicateFieldNumber_allocate);
  rb_define_method(cDuplicateFieldNumber.klass, "initialize", VALUEFUNC(_wrap_new_DuplicateFieldNumber), -1);
  cDuplicateFieldNumber.mark = 0;
  cDuplicateFieldNumber.destroy = (void (*)(void *)) free_FIX_DuplicateFieldNumber;
  cDuplicateFieldNumber.trackObjects = 0;
  
  cInvalidMessageType.klass = rb_define_class_under(mQuickfix, "InvalidMessageType", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvalidMessageType, (void *) &cInvalidMessageType);
  rb_define_alloc_func(cInvalidMessageType.klass, _wrap_InvalidMessageType_allocate);
  rb_define_method(cInvalidMessageType.klass, "initialize", VALUEFUNC(_wrap_new_InvalidMessageType), -1);
  cInvalidMessageType.mark = 0;
  cInvalidMessageType.destroy = (void (*)(void *)) free_FIX_InvalidMessageType;
  cInvalidMessageType.trackObjects = 0;
  
  cUnsupportedMessageType.klass = rb_define_class_under(mQuickfix, "UnsupportedMessageType", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnsupportedMessageType, (void *) &cUnsupportedMessageType);
  rb_define_alloc_func(cUnsupportedMessageType.klass, _wrap_UnsupportedMessageType_allocate);
  rb_define_method(cUnsupportedMessageType.klass, "initialize", VALUEFUNC(_wrap_new_UnsupportedMessageType), -1);
  cUnsupportedMessageType.mark = 0;
  cUnsupportedMessageType.destroy = (void (*)(void *)) free_FIX_UnsupportedMessageType;
  cUnsupportedMessageType.trackObjects = 0;
  
  cUnsupportedVersion.klass = rb_define_class_under(mQuickfix, "UnsupportedVersion", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnsupportedVersion, (void *) &cUnsupportedVersion);
  rb_define_alloc_func(cUnsupportedVersion.klass, _wrap_UnsupportedVersion_allocate);
  rb_define_method(cUnsupportedVersion.klass, "initialize", VALUEFUNC(_wrap_new_UnsupportedVersion), -1);
  cUnsupportedVersion.mark = 0;
  cUnsupportedVersion.destroy = (void (*)(void *)) free_FIX_UnsupportedVersion;
  cUnsupportedVersion.trackObjects = 0;
  
  cTagOutOfOrder.klass = rb_define_class_under(mQuickfix, "TagOutOfOrder", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TagOutOfOrder, (void *) &cTagOutOfOrder);
  rb_define_alloc_func(cTagOutOfOrder.klass, _wrap_TagOutOfOrder_allocate);
  rb_define_method(cTagOutOfOrder.klass, "initialize", VALUEFUNC(_wrap_new_TagOutOfOrder), -1);
  rb_define_method(cTagOutOfOrder.klass, "field=", VALUEFUNC(_wrap_TagOutOfOrder_field_set), -1);
  rb_define_method(cTagOutOfOrder.klass, "field", VALUEFUNC(_wrap_TagOutOfOrder_field_get), -1);
  cTagOutOfOrder.mark = 0;
  cTagOutOfOrder.destroy = (void (*)(void *)) free_FIX_TagOutOfOrder;
  cTagOutOfOrder.trackObjects = 0;
  
  cRepeatedTag.klass = rb_define_class_under(mQuickfix, "RepeatedTag", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepeatedTag, (void *) &cRepeatedTag);
  rb_define_alloc_func(cRepeatedTag.klass, _wrap_RepeatedTag_allocate);
  rb_define_method(cRepeatedTag.klass, "initialize", VALUEFUNC(_wrap_new_RepeatedTag), -1);
  rb_define_method(cRepeatedTag.klass, "field=", VALUEFUNC(_wrap_RepeatedTag_field_set), -1);
  rb_define_method(cRepeatedTag.klass, "field", VALUEFUNC(_wrap_RepeatedTag_field_get), -1);
  cRepeatedTag.mark = 0;
  cRepeatedTag.destroy = (void (*)(void *)) free_FIX_RepeatedTag;
  cRepeatedTag.trackObjects = 0;
  
  cRepeatingGroupCountMismatch.klass = rb_define_class_under(mQuickfix, "RepeatingGroupCountMismatch", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, (void *) &cRepeatingGroupCountMismatch);
  rb_define_alloc_func(cRepeatingGroupCountMismatch.klass, _wrap_RepeatingGroupCountMismatch_allocate);
  rb_define_method(cRepeatingGroupCountMismatch.klass, "initialize", VALUEFUNC(_wrap_new_RepeatingGroupCountMismatch), -1);
  rb_define_method(cRepeatingGroupCountMismatch.klass, "field=", VALUEFUNC(_wrap_RepeatingGroupCountMismatch_field_set), -1);
  rb_define_method(cRepeatingGroupCountMismatch.klass, "field", VALUEFUNC(_wrap_RepeatingGroupCountMismatch_field_get), -1);
  cRepeatingGroupCountMismatch.mark = 0;
  cRepeatingGroupCountMismatch.destroy = (void (*)(void *)) free_FIX_RepeatingGroupCountMismatch;
  cRepeatingGroupCountMismatch.trackObjects = 0;
  
  cDoNotSend.klass = rb_define_class_under(mQuickfix, "DoNotSend", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DoNotSend, (void *) &cDoNotSend);
  rb_define_alloc_func(cDoNotSend.klass, _wrap_DoNotSend_allocate);
  rb_define_method(cDoNotSend.klass, "initialize", VALUEFUNC(_wrap_new_DoNotSend), -1);
  cDoNotSend.mark = 0;
  cDoNotSend.destroy = (void (*)(void *)) free_FIX_DoNotSend;
  cDoNotSend.trackObjects = 0;
  
  cRejectLogon.klass = rb_define_class_under(mQuickfix, "RejectLogon", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RejectLogon, (void *) &cRejectLogon);
  rb_define_alloc_func(cRejectLogon.klass, _wrap_RejectLogon_allocate);
  rb_define_method(cRejectLogon.klass, "initialize", VALUEFUNC(_wrap_new_RejectLogon), -1);
  cRejectLogon.mark = 0;
  cRejectLogon.destroy = (void (*)(void *)) free_FIX_RejectLogon;
  cRejectLogon.trackObjects = 0;
  
  cSessionNotFound.klass = rb_define_class_under(mQuickfix, "SessionNotFound", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionNotFound, (void *) &cSessionNotFound);
  rb_define_alloc_func(cSessionNotFound.klass, _wrap_SessionNotFound_allocate);
  rb_define_method(cSessionNotFound.klass, "initialize", VALUEFUNC(_wrap_new_SessionNotFound), -1);
  cSessionNotFound.mark = 0;
  cSessionNotFound.destroy = (void (*)(void *)) free_FIX_SessionNotFound;
  cSessionNotFound.trackObjects = 0;
  
  cIOException.klass = rb_define_class_under(mQuickfix, "IOException", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOException, (void *) &cIOException);
  rb_define_alloc_func(cIOException.klass, _wrap_IOException_allocate);
  rb_define_method(cIOException.klass, "initialize", VALUEFUNC(_wrap_new_IOException), -1);
  cIOException.mark = 0;
  cIOException.destroy = (void (*)(void *)) free_FIX_IOException;
  cIOException.trackObjects = 0;
  
  cSocketException.klass = rb_define_class_under(mQuickfix, "SocketException", ((swig_class *) SWIGTYPE_p_FIX__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketException, (void *) &cSocketException);
  rb_define_alloc_func(cSocketException.klass, _wrap_SocketException_allocate);
  rb_define_method(cSocketException.klass, "initialize", VALUEFUNC(_wrap_new_SocketException), -1);
  rb_define_method(cSocketException.klass, "errorToWhat", VALUEFUNC(_wrap_SocketException_errorToWhat), -1);
  rb_define_method(cSocketException.klass, "error=", VALUEFUNC(_wrap_SocketException_error_set), -1);
  rb_define_method(cSocketException.klass, "error", VALUEFUNC(_wrap_SocketException_error_get), -1);
  cSocketException.mark = 0;
  cSocketException.destroy = (void (*)(void *)) free_FIX_SocketException;
  cSocketException.trackObjects = 0;
  
  cSocketSendFailed.klass = rb_define_class_under(mQuickfix, "SocketSendFailed", ((swig_class *) SWIGTYPE_p_FIX__SocketException->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketSendFailed, (void *) &cSocketSendFailed);
  rb_define_alloc_func(cSocketSendFailed.klass, _wrap_SocketSendFailed_allocate);
  rb_define_method(cSocketSendFailed.klass, "initialize", VALUEFUNC(_wrap_new_SocketSendFailed), -1);
  cSocketSendFailed.mark = 0;
  cSocketSendFailed.destroy = (void (*)(void *)) free_FIX_SocketSendFailed;
  cSocketSendFailed.trackObjects = 0;
  
  cSocketRecvFailed.klass = rb_define_class_under(mQuickfix, "SocketRecvFailed", ((swig_class *) SWIGTYPE_p_FIX__SocketException->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketRecvFailed, (void *) &cSocketRecvFailed);
  rb_define_alloc_func(cSocketRecvFailed.klass, _wrap_SocketRecvFailed_allocate);
  rb_define_method(cSocketRecvFailed.klass, "initialize", VALUEFUNC(_wrap_new_SocketRecvFailed), -1);
  cSocketRecvFailed.mark = 0;
  cSocketRecvFailed.destroy = (void (*)(void *)) free_FIX_SocketRecvFailed;
  cSocketRecvFailed.trackObjects = 0;
  
  cSocketCloseFailed.klass = rb_define_class_under(mQuickfix, "SocketCloseFailed", ((swig_class *) SWIGTYPE_p_FIX__SocketException->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketCloseFailed, (void *) &cSocketCloseFailed);
  rb_define_alloc_func(cSocketCloseFailed.klass, _wrap_SocketCloseFailed_allocate);
  rb_define_method(cSocketCloseFailed.klass, "initialize", VALUEFUNC(_wrap_new_SocketCloseFailed), -1);
  cSocketCloseFailed.mark = 0;
  cSocketCloseFailed.destroy = (void (*)(void *)) free_FIX_SocketCloseFailed;
  cSocketCloseFailed.trackObjects = 0;
  
  cFieldBase.klass = rb_define_class_under(mQuickfix, "FieldBase", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldBase, (void *) &cFieldBase);
  rb_define_alloc_func(cFieldBase.klass, _wrap_FieldBase_allocate);
  rb_define_method(cFieldBase.klass, "initialize", VALUEFUNC(_wrap_new_FieldBase), -1);
  rb_define_method(cFieldBase.klass, "setField", VALUEFUNC(_wrap_FieldBase_setField), -1);
  rb_define_method(cFieldBase.klass, "setString", VALUEFUNC(_wrap_FieldBase_setString), -1);
  rb_define_method(cFieldBase.klass, "getField", VALUEFUNC(_wrap_FieldBase_getField), -1);
  rb_define_method(cFieldBase.klass, "getString", VALUEFUNC(_wrap_FieldBase_getString), -1);
  rb_define_method(cFieldBase.klass, "getValue", VALUEFUNC(_wrap_FieldBase_getValue), -1);
  rb_define_method(cFieldBase.klass, "getLength", VALUEFUNC(_wrap_FieldBase_getLength), -1);
  rb_define_method(cFieldBase.klass, "getTotal", VALUEFUNC(_wrap_FieldBase_getTotal), -1);
  rb_define_method(cFieldBase.klass, "<", VALUEFUNC(_wrap_FieldBase___lt__), -1);
  rb_define_method(cFieldBase.klass, "to_s", VALUEFUNC(_wrap_FieldBase___str__), -1);
  cFieldBase.mark = 0;
  cFieldBase.destroy = (void (*)(void *)) free_FIX_FieldBase;
  cFieldBase.trackObjects = 0;
  
  cStringField.klass = rb_define_class_under(mQuickfix, "StringField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StringField, (void *) &cStringField);
  rb_define_alloc_func(cStringField.klass, _wrap_StringField_allocate);
  rb_define_method(cStringField.klass, "initialize", VALUEFUNC(_wrap_new_StringField), -1);
  rb_define_method(cStringField.klass, "setValue", VALUEFUNC(_wrap_StringField_setValue), -1);
  rb_define_method(cStringField.klass, "getValue", VALUEFUNC(_wrap_StringField_getValue), -1);
  rb_define_method(cStringField.klass, "<", VALUEFUNC(_wrap_StringField___lt__), -1);
  rb_define_method(cStringField.klass, ">", VALUEFUNC(_wrap_StringField___gt__), -1);
  rb_define_method(cStringField.klass, "==", VALUEFUNC(_wrap_StringField___eq__), -1);
  rb_define_method(cStringField.klass, "<=", VALUEFUNC(_wrap_StringField___le__), -1);
  rb_define_method(cStringField.klass, ">=", VALUEFUNC(_wrap_StringField___ge__), -1);
  cStringField.mark = 0;
  cStringField.destroy = (void (*)(void *)) free_FIX_StringField;
  cStringField.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);
  
  cCharField.klass = rb_define_class_under(mQuickfix, "CharField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CharField, (void *) &cCharField);
  rb_define_alloc_func(cCharField.klass, _wrap_CharField_allocate);
  rb_define_method(cCharField.klass, "initialize", VALUEFUNC(_wrap_new_CharField), -1);
  rb_define_method(cCharField.klass, "setValue", VALUEFUNC(_wrap_CharField_setValue), -1);
  rb_define_method(cCharField.klass, "getValue", VALUEFUNC(_wrap_CharField_getValue), -1);
  cCharField.mark = 0;
  cCharField.destroy = (void (*)(void *)) free_FIX_CharField;
  cCharField.trackObjects = 0;
  
  cDoubleField.klass = rb_define_class_under(mQuickfix, "DoubleField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DoubleField, (void *) &cDoubleField);
  rb_define_alloc_func(cDoubleField.klass, _wrap_DoubleField_allocate);
  rb_define_method(cDoubleField.klass, "initialize", VALUEFUNC(_wrap_new_DoubleField), -1);
  rb_define_method(cDoubleField.klass, "setValue", VALUEFUNC(_wrap_DoubleField_setValue), -1);
  rb_define_method(cDoubleField.klass, "getValue", VALUEFUNC(_wrap_DoubleField_getValue), -1);
  cDoubleField.mark = 0;
  cDoubleField.destroy = (void (*)(void *)) free_FIX_DoubleField;
  cDoubleField.trackObjects = 0;
  
  cIntField.klass = rb_define_class_under(mQuickfix, "IntField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IntField, (void *) &cIntField);
  rb_define_alloc_func(cIntField.klass, _wrap_IntField_allocate);
  rb_define_method(cIntField.klass, "initialize", VALUEFUNC(_wrap_new_IntField), -1);
  rb_define_method(cIntField.klass, "setValue", VALUEFUNC(_wrap_IntField_setValue), -1);
  rb_define_method(cIntField.klass, "getValue", VALUEFUNC(_wrap_IntField_getValue), -1);
  cIntField.mark = 0;
  cIntField.destroy = (void (*)(void *)) free_FIX_IntField;
  cIntField.trackObjects = 0;
  
  cBoolField.klass = rb_define_class_under(mQuickfix, "BoolField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BoolField, (void *) &cBoolField);
  rb_define_alloc_func(cBoolField.klass, _wrap_BoolField_allocate);
  rb_define_method(cBoolField.klass, "initialize", VALUEFUNC(_wrap_new_BoolField), -1);
  rb_define_method(cBoolField.klass, "setValue", VALUEFUNC(_wrap_BoolField_setValue), -1);
  rb_define_method(cBoolField.klass, "getValue", VALUEFUNC(_wrap_BoolField_getValue), -1);
  cBoolField.mark = 0;
  cBoolField.destroy = (void (*)(void *)) free_FIX_BoolField;
  cBoolField.trackObjects = 0;
  
  cUtcTimeStampField.klass = rb_define_class_under(mQuickfix, "UtcTimeStampField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UtcTimeStampField, (void *) &cUtcTimeStampField);
  rb_define_alloc_func(cUtcTimeStampField.klass, _wrap_UtcTimeStampField_allocate);
  rb_define_method(cUtcTimeStampField.klass, "initialize", VALUEFUNC(_wrap_new_UtcTimeStampField), -1);
  rb_define_method(cUtcTimeStampField.klass, "setValue", VALUEFUNC(_wrap_UtcTimeStampField_setValue), -1);
  rb_define_method(cUtcTimeStampField.klass, "getValue", VALUEFUNC(_wrap_UtcTimeStampField_getValue), -1);
  rb_define_method(cUtcTimeStampField.klass, "<", VALUEFUNC(_wrap_UtcTimeStampField___lt__), -1);
  rb_define_method(cUtcTimeStampField.klass, "==", VALUEFUNC(_wrap_UtcTimeStampField___eq__), -1);
  cUtcTimeStampField.mark = 0;
  cUtcTimeStampField.destroy = (void (*)(void *)) free_FIX_UtcTimeStampField;
  cUtcTimeStampField.trackObjects = 0;
  
  cUtcDateField.klass = rb_define_class_under(mQuickfix, "UtcDateField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UtcDateField, (void *) &cUtcDateField);
  rb_define_alloc_func(cUtcDateField.klass, _wrap_UtcDateField_allocate);
  rb_define_method(cUtcDateField.klass, "initialize", VALUEFUNC(_wrap_new_UtcDateField), -1);
  rb_define_method(cUtcDateField.klass, "setValue", VALUEFUNC(_wrap_UtcDateField_setValue), -1);
  rb_define_method(cUtcDateField.klass, "getValue", VALUEFUNC(_wrap_UtcDateField_getValue), -1);
  rb_define_method(cUtcDateField.klass, "<", VALUEFUNC(_wrap_UtcDateField___lt__), -1);
  rb_define_method(cUtcDateField.klass, "==", VALUEFUNC(_wrap_UtcDateField___eq__), -1);
  cUtcDateField.mark = 0;
  cUtcDateField.destroy = (void (*)(void *)) free_FIX_UtcDateField;
  cUtcDateField.trackObjects = 0;
  
  cUtcTimeOnlyField.klass = rb_define_class_under(mQuickfix, "UtcTimeOnlyField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UtcTimeOnlyField, (void *) &cUtcTimeOnlyField);
  rb_define_alloc_func(cUtcTimeOnlyField.klass, _wrap_UtcTimeOnlyField_allocate);
  rb_define_method(cUtcTimeOnlyField.klass, "initialize", VALUEFUNC(_wrap_new_UtcTimeOnlyField), -1);
  rb_define_method(cUtcTimeOnlyField.klass, "setValue", VALUEFUNC(_wrap_UtcTimeOnlyField_setValue), -1);
  rb_define_method(cUtcTimeOnlyField.klass, "getValue", VALUEFUNC(_wrap_UtcTimeOnlyField_getValue), -1);
  rb_define_method(cUtcTimeOnlyField.klass, "<", VALUEFUNC(_wrap_UtcTimeOnlyField___lt__), -1);
  rb_define_method(cUtcTimeOnlyField.klass, "==", VALUEFUNC(_wrap_UtcTimeOnlyField___eq__), -1);
  cUtcTimeOnlyField.mark = 0;
  cUtcTimeOnlyField.destroy = (void (*)(void *)) free_FIX_UtcTimeOnlyField;
  cUtcTimeOnlyField.trackObjects = 0;
  
  cCheckSumField.klass = rb_define_class_under(mQuickfix, "CheckSumField", ((swig_class *) SWIGTYPE_p_FIX__FieldBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CheckSumField, (void *) &cCheckSumField);
  rb_define_alloc_func(cCheckSumField.klass, _wrap_CheckSumField_allocate);
  rb_define_method(cCheckSumField.klass, "initialize", VALUEFUNC(_wrap_new_CheckSumField), -1);
  rb_define_method(cCheckSumField.klass, "setValue", VALUEFUNC(_wrap_CheckSumField_setValue), -1);
  rb_define_method(cCheckSumField.klass, "getValue", VALUEFUNC(_wrap_CheckSumField_getValue), -1);
  cCheckSumField.mark = 0;
  cCheckSumField.destroy = (void (*)(void *)) free_FIX_CheckSumField;
  cCheckSumField.trackObjects = 0;
  
  cFieldMap.klass = rb_define_class_under(mQuickfix, "FieldMap", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FieldMap, (void *) &cFieldMap);
  rb_define_alloc_func(cFieldMap.klass, _wrap_FieldMap_allocate);
  rb_define_method(cFieldMap.klass, "initialize", VALUEFUNC(_wrap_new_FieldMap), -1);
  rb_define_method(cFieldMap.klass, "setField", VALUEFUNC(_wrap_FieldMap_setField), -1);
  rb_define_method(cFieldMap.klass, "getField", VALUEFUNC(_wrap_FieldMap_getField), -1);
  rb_define_method(cFieldMap.klass, "getFieldRef", VALUEFUNC(_wrap_FieldMap_getFieldRef), -1);
  rb_define_method(cFieldMap.klass, "getFieldPtr", VALUEFUNC(_wrap_FieldMap_getFieldPtr), -1);
  rb_define_method(cFieldMap.klass, "isSetField", VALUEFUNC(_wrap_FieldMap_isSetField), -1);
  rb_define_method(cFieldMap.klass, "removeField", VALUEFUNC(_wrap_FieldMap_removeField), -1);
  rb_define_method(cFieldMap.klass, "addGroup", VALUEFUNC(_wrap_FieldMap_addGroup), -1);
  rb_define_method(cFieldMap.klass, "replaceGroup", VALUEFUNC(_wrap_FieldMap_replaceGroup), -1);
  rb_define_method(cFieldMap.klass, "getGroup", VALUEFUNC(_wrap_FieldMap_getGroup), -1);
  rb_define_method(cFieldMap.klass, "getGroupRef", VALUEFUNC(_wrap_FieldMap_getGroupRef), -1);
  rb_define_method(cFieldMap.klass, "getGroupPtr", VALUEFUNC(_wrap_FieldMap_getGroupPtr), -1);
  rb_define_method(cFieldMap.klass, "removeGroup", VALUEFUNC(_wrap_FieldMap_removeGroup), -1);
  rb_define_method(cFieldMap.klass, "hasGroup", VALUEFUNC(_wrap_FieldMap_hasGroup), -1);
  rb_define_method(cFieldMap.klass, "groupCount", VALUEFUNC(_wrap_FieldMap_groupCount), -1);
  rb_define_method(cFieldMap.klass, "clear", VALUEFUNC(_wrap_FieldMap_clear), -1);
  rb_define_method(cFieldMap.klass, "isEmpty", VALUEFUNC(_wrap_FieldMap_isEmpty), -1);
  rb_define_method(cFieldMap.klass, "totalFields", VALUEFUNC(_wrap_FieldMap_totalFields), -1);
  rb_define_method(cFieldMap.klass, "calculateString", VALUEFUNC(_wrap_FieldMap_calculateString), -1);
  rb_define_method(cFieldMap.klass, "calculateLength", VALUEFUNC(_wrap_FieldMap_calculateLength), -1);
  rb_define_method(cFieldMap.klass, "calculateTotal", VALUEFUNC(_wrap_FieldMap_calculateTotal), -1);
  rb_define_method(cFieldMap.klass, "begin", VALUEFUNC(_wrap_FieldMap_begin), -1);
  rb_define_method(cFieldMap.klass, "end", VALUEFUNC(_wrap_FieldMap_end), -1);
  rb_define_method(cFieldMap.klass, "g_begin", VALUEFUNC(_wrap_FieldMap_g_begin), -1);
  rb_define_method(cFieldMap.klass, "g_end", VALUEFUNC(_wrap_FieldMap_g_end), -1);
  cFieldMap.mark = 0;
  cFieldMap.destroy = (void (*)(void *)) free_FIX_FieldMap;
  cFieldMap.trackObjects = 0;
  rb_define_singleton_method(mQuickfix, "headerOrder", VALUEFUNC(headerOrder_get), 0);
  
  cMessage.klass = rb_define_class_under(mQuickfix, "Message", ((swig_class *) SWIGTYPE_p_FIX__FieldMap->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Message, (void *) &cMessage);
  rb_define_alloc_func(cMessage.klass, _wrap_Message_allocate);
  rb_define_method(cMessage.klass, "initialize", VALUEFUNC(_wrap_new_Message), -1);
  rb_define_singleton_method(cMessage.klass, "InitializeXML", VALUEFUNC(_wrap_Message_InitializeXML), -1);
  rb_define_method(cMessage.klass, "addGroup", VALUEFUNC(_wrap_Message_addGroup), -1);
  rb_define_method(cMessage.klass, "replaceGroup", VALUEFUNC(_wrap_Message_replaceGroup), -1);
  rb_define_method(cMessage.klass, "getGroup", VALUEFUNC(_wrap_Message_getGroup), -1);
  rb_define_method(cMessage.klass, "removeGroup", VALUEFUNC(_wrap_Message_removeGroup), -1);
  rb_define_method(cMessage.klass, "hasGroup", VALUEFUNC(_wrap_Message_hasGroup), -1);
  rb_define_method(cMessage.klass, "toString", VALUEFUNC(_wrap_Message_toString), -1);
  rb_define_method(cMessage.klass, "toXML", VALUEFUNC(_wrap_Message_toXML), -1);
  rb_define_method(cMessage.klass, "reverseRoute", VALUEFUNC(_wrap_Message_reverseRoute), -1);
  rb_define_method(cMessage.klass, "setString", VALUEFUNC(_wrap_Message_setString), -1);
  rb_define_method(cMessage.klass, "setGroup", VALUEFUNC(_wrap_Message_setGroup), -1);
  rb_define_method(cMessage.klass, "setStringHeader", VALUEFUNC(_wrap_Message_setStringHeader), -1);
  rb_define_method(cMessage.klass, "getHeader", VALUEFUNC(_wrap_Message_getHeader), -1);
  rb_define_method(cMessage.klass, "getTrailer", VALUEFUNC(_wrap_Message_getTrailer), -1);
  rb_define_method(cMessage.klass, "hasValidStructure", VALUEFUNC(_wrap_Message_hasValidStructure), -1);
  rb_define_method(cMessage.klass, "bodyLength", VALUEFUNC(_wrap_Message_bodyLength), -1);
  rb_define_method(cMessage.klass, "checkSum", VALUEFUNC(_wrap_Message_checkSum), -1);
  rb_define_method(cMessage.klass, "isAdmin", VALUEFUNC(_wrap_Message_isAdmin), -1);
  rb_define_method(cMessage.klass, "isApp", VALUEFUNC(_wrap_Message_isApp), -1);
  rb_define_method(cMessage.klass, "isEmpty", VALUEFUNC(_wrap_Message_isEmpty), -1);
  rb_define_method(cMessage.klass, "clear", VALUEFUNC(_wrap_Message_clear), -1);
  rb_define_singleton_method(cMessage.klass, "isAdminMsgType", VALUEFUNC(_wrap_Message_isAdminMsgType), -1);
  rb_define_singleton_method(cMessage.klass, "toApplVerID", VALUEFUNC(_wrap_Message_toApplVerID), -1);
  rb_define_singleton_method(cMessage.klass, "toBeginString", VALUEFUNC(_wrap_Message_toBeginString), -1);
  rb_define_singleton_method(cMessage.klass, "isHeaderField", VALUEFUNC(_wrap_Message_isHeaderField), -1);
  rb_define_singleton_method(cMessage.klass, "isTrailerField", VALUEFUNC(_wrap_Message_isTrailerField), -1);
  rb_define_method(cMessage.klass, "getSessionID", VALUEFUNC(_wrap_Message_getSessionID), -1);
  rb_define_method(cMessage.klass, "setSessionID", VALUEFUNC(_wrap_Message_setSessionID), -1);
  rb_define_method(cMessage.klass, "to_s", VALUEFUNC(_wrap_Message___str__), -1);
  cMessage.mark = 0;
  cMessage.destroy = (void (*)(void *)) free_FIX_Message;
  cMessage.trackObjects = 0;
  rb_define_module_function(mQuickfix, "identifyType", VALUEFUNC(_wrap_identifyType), -1);
  
  cGroup.klass = rb_define_class_under(mQuickfix, "Group", ((swig_class *) SWIGTYPE_p_FIX__FieldMap->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Group, (void *) &cGroup);
  rb_define_alloc_func(cGroup.klass, _wrap_Group_allocate);
  rb_define_method(cGroup.klass, "initialize", VALUEFUNC(_wrap_new_Group), -1);
  rb_define_method(cGroup.klass, "field", VALUEFUNC(_wrap_Group_field), -1);
  rb_define_method(cGroup.klass, "delim", VALUEFUNC(_wrap_Group_delim), -1);
  rb_define_method(cGroup.klass, "addGroup", VALUEFUNC(_wrap_Group_addGroup), -1);
  rb_define_method(cGroup.klass, "replaceGroup", VALUEFUNC(_wrap_Group_replaceGroup), -1);
  rb_define_method(cGroup.klass, "getGroup", VALUEFUNC(_wrap_Group_getGroup), -1);
  rb_define_method(cGroup.klass, "removeGroup", VALUEFUNC(_wrap_Group_removeGroup), -1);
  rb_define_method(cGroup.klass, "hasGroup", VALUEFUNC(_wrap_Group_hasGroup), -1);
  cGroup.mark = 0;
  cGroup.destroy = (void (*)(void *)) free_FIX_Group;
  cGroup.trackObjects = 0;
  
  cRelatedPartyID.klass = rb_define_class_under(mQuickfix, "RelatedPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartyID, (void *) &cRelatedPartyID);
  rb_define_alloc_func(cRelatedPartyID.klass, _wrap_RelatedPartyID_allocate);
  rb_define_method(cRelatedPartyID.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartyID), -1);
  cRelatedPartyID.mark = 0;
  cRelatedPartyID.destroy = (void (*)(void *)) free_FIX_RelatedPartyID;
  cRelatedPartyID.trackObjects = 0;
  
  cMaxPriceLevels.klass = rb_define_class_under(mQuickfix, "MaxPriceLevels", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxPriceLevels, (void *) &cMaxPriceLevels);
  rb_define_alloc_func(cMaxPriceLevels.klass, _wrap_MaxPriceLevels_allocate);
  rb_define_method(cMaxPriceLevels.klass, "initialize", VALUEFUNC(_wrap_new_MaxPriceLevels), -1);
  cMaxPriceLevels.mark = 0;
  cMaxPriceLevels.destroy = (void (*)(void *)) free_FIX_MaxPriceLevels;
  cMaxPriceLevels.trackObjects = 0;
  
  cDerivativeEncodedIssuer.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedIssuer, (void *) &cDerivativeEncodedIssuer);
  rb_define_alloc_func(cDerivativeEncodedIssuer.klass, _wrap_DerivativeEncodedIssuer_allocate);
  rb_define_method(cDerivativeEncodedIssuer.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedIssuer), -1);
  cDerivativeEncodedIssuer.mark = 0;
  cDerivativeEncodedIssuer.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedIssuer;
  cDerivativeEncodedIssuer.trackObjects = 0;
  
  cNoCompIDs.klass = rb_define_class_under(mQuickfix, "NoCompIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoCompIDs, (void *) &cNoCompIDs);
  rb_define_alloc_func(cNoCompIDs.klass, _wrap_NoCompIDs_allocate);
  rb_define_method(cNoCompIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoCompIDs), -1);
  cNoCompIDs.mark = 0;
  cNoCompIDs.destroy = (void (*)(void *)) free_FIX_NoCompIDs;
  cNoCompIDs.trackObjects = 0;
  
  cSettlInstRefID.klass = rb_define_class_under(mQuickfix, "SettlInstRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstRefID, (void *) &cSettlInstRefID);
  rb_define_alloc_func(cSettlInstRefID.klass, _wrap_SettlInstRefID_allocate);
  rb_define_method(cSettlInstRefID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstRefID), -1);
  cSettlInstRefID.mark = 0;
  cSettlInstRefID.destroy = (void (*)(void *)) free_FIX_SettlInstRefID;
  cSettlInstRefID.trackObjects = 0;
  
  cNestedPartyID.klass = rb_define_class_under(mQuickfix, "NestedPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartyID, (void *) &cNestedPartyID);
  rb_define_alloc_func(cNestedPartyID.klass, _wrap_NestedPartyID_allocate);
  rb_define_method(cNestedPartyID.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartyID), -1);
  cNestedPartyID.mark = 0;
  cNestedPartyID.destroy = (void (*)(void *)) free_FIX_NestedPartyID;
  cNestedPartyID.trackObjects = 0;
  
  cDetachmentPoint.klass = rb_define_class_under(mQuickfix, "DetachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DetachmentPoint, (void *) &cDetachmentPoint);
  rb_define_alloc_func(cDetachmentPoint.klass, _wrap_DetachmentPoint_allocate);
  rb_define_method(cDetachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_DetachmentPoint), -1);
  cDetachmentPoint.mark = 0;
  cDetachmentPoint.destroy = (void (*)(void *)) free_FIX_DetachmentPoint;
  cDetachmentPoint.trackObjects = 0;
  
  cLateIndicator.klass = rb_define_class_under(mQuickfix, "LateIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LateIndicator, (void *) &cLateIndicator);
  rb_define_alloc_func(cLateIndicator.klass, _wrap_LateIndicator_allocate);
  rb_define_method(cLateIndicator.klass, "initialize", VALUEFUNC(_wrap_new_LateIndicator), -1);
  cLateIndicator.mark = 0;
  cLateIndicator.destroy = (void (*)(void *)) free_FIX_LateIndicator;
  cLateIndicator.trackObjects = 0;
  
  cRiskEncodedSecurityDesc.klass = rb_define_class_under(mQuickfix, "RiskEncodedSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskEncodedSecurityDesc, (void *) &cRiskEncodedSecurityDesc);
  rb_define_alloc_func(cRiskEncodedSecurityDesc.klass, _wrap_RiskEncodedSecurityDesc_allocate);
  rb_define_method(cRiskEncodedSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_RiskEncodedSecurityDesc), -1);
  cRiskEncodedSecurityDesc.mark = 0;
  cRiskEncodedSecurityDesc.destroy = (void (*)(void *)) free_FIX_RiskEncodedSecurityDesc;
  cRiskEncodedSecurityDesc.trackObjects = 0;
  
  cRelationshipRiskSecuritySubType.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecuritySubType, (void *) &cRelationshipRiskSecuritySubType);
  rb_define_alloc_func(cRelationshipRiskSecuritySubType.klass, _wrap_RelationshipRiskSecuritySubType_allocate);
  rb_define_method(cRelationshipRiskSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecuritySubType), -1);
  cRelationshipRiskSecuritySubType.mark = 0;
  cRelationshipRiskSecuritySubType.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecuritySubType;
  cRelationshipRiskSecuritySubType.trackObjects = 0;
  
  cSecurityListID.klass = rb_define_class_under(mQuickfix, "SecurityListID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListID, (void *) &cSecurityListID);
  rb_define_alloc_func(cSecurityListID.klass, _wrap_SecurityListID_allocate);
  rb_define_method(cSecurityListID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListID), -1);
  cSecurityListID.mark = 0;
  cSecurityListID.destroy = (void (*)(void *)) free_FIX_SecurityListID;
  cSecurityListID.trackObjects = 0;
  
  cDerivativeFlowScheduleType.klass = rb_define_class_under(mQuickfix, "DerivativeFlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeFlowScheduleType, (void *) &cDerivativeFlowScheduleType);
  rb_define_alloc_func(cDerivativeFlowScheduleType.klass, _wrap_DerivativeFlowScheduleType_allocate);
  rb_define_method(cDerivativeFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeFlowScheduleType), -1);
  cDerivativeFlowScheduleType.mark = 0;
  cDerivativeFlowScheduleType.destroy = (void (*)(void *)) free_FIX_DerivativeFlowScheduleType;
  cDerivativeFlowScheduleType.trackObjects = 0;
  
  cEncodedSymbolLen.klass = rb_define_class_under(mQuickfix, "EncodedSymbolLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSymbolLen, (void *) &cEncodedSymbolLen);
  rb_define_alloc_func(cEncodedSymbolLen.klass, _wrap_EncodedSymbolLen_allocate);
  rb_define_method(cEncodedSymbolLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSymbolLen), -1);
  cEncodedSymbolLen.mark = 0;
  cEncodedSymbolLen.destroy = (void (*)(void *)) free_FIX_EncodedSymbolLen;
  cEncodedSymbolLen.trackObjects = 0;
  
  cFlexibleIndicator.klass = rb_define_class_under(mQuickfix, "FlexibleIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FlexibleIndicator, (void *) &cFlexibleIndicator);
  rb_define_alloc_func(cFlexibleIndicator.klass, _wrap_FlexibleIndicator_allocate);
  rb_define_method(cFlexibleIndicator.klass, "initialize", VALUEFUNC(_wrap_new_FlexibleIndicator), -1);
  cFlexibleIndicator.mark = 0;
  cFlexibleIndicator.destroy = (void (*)(void *)) free_FIX_FlexibleIndicator;
  cFlexibleIndicator.trackObjects = 0;
  
  cNoExecInstRules.klass = rb_define_class_under(mQuickfix, "NoExecInstRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoExecInstRules, (void *) &cNoExecInstRules);
  rb_define_alloc_func(cNoExecInstRules.klass, _wrap_NoExecInstRules_allocate);
  rb_define_method(cNoExecInstRules.klass, "initialize", VALUEFUNC(_wrap_new_NoExecInstRules), -1);
  cNoExecInstRules.mark = 0;
  cNoExecInstRules.destroy = (void (*)(void *)) free_FIX_NoExecInstRules;
  cNoExecInstRules.trackObjects = 0;
  
  cSideTrdRegTimestamp.klass = rb_define_class_under(mQuickfix, "SideTrdRegTimestamp", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdRegTimestamp, (void *) &cSideTrdRegTimestamp);
  rb_define_alloc_func(cSideTrdRegTimestamp.klass, _wrap_SideTrdRegTimestamp_allocate);
  rb_define_method(cSideTrdRegTimestamp.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdRegTimestamp), -1);
  cSideTrdRegTimestamp.mark = 0;
  cSideTrdRegTimestamp.destroy = (void (*)(void *)) free_FIX_SideTrdRegTimestamp;
  cSideTrdRegTimestamp.trackObjects = 0;
  
  cDeliveryForm.klass = rb_define_class_under(mQuickfix, "DeliveryForm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliveryForm, (void *) &cDeliveryForm);
  rb_define_alloc_func(cDeliveryForm.klass, _wrap_DeliveryForm_allocate);
  rb_define_method(cDeliveryForm.klass, "initialize", VALUEFUNC(_wrap_new_DeliveryForm), -1);
  cDeliveryForm.mark = 0;
  cDeliveryForm.destroy = (void (*)(void *)) free_FIX_DeliveryForm;
  cDeliveryForm.trackObjects = 0;
  
  cExecRestatementReason.klass = rb_define_class_under(mQuickfix, "ExecRestatementReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecRestatementReason, (void *) &cExecRestatementReason);
  rb_define_alloc_func(cExecRestatementReason.klass, _wrap_ExecRestatementReason_allocate);
  rb_define_method(cExecRestatementReason.klass, "initialize", VALUEFUNC(_wrap_new_ExecRestatementReason), -1);
  cExecRestatementReason.mark = 0;
  cExecRestatementReason.destroy = (void (*)(void *)) free_FIX_ExecRestatementReason;
  cExecRestatementReason.trackObjects = 0;
  
  cMidYield.klass = rb_define_class_under(mQuickfix, "MidYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MidYield, (void *) &cMidYield);
  rb_define_alloc_func(cMidYield.klass, _wrap_MidYield_allocate);
  rb_define_method(cMidYield.klass, "initialize", VALUEFUNC(_wrap_new_MidYield), -1);
  cMidYield.mark = 0;
  cMidYield.destroy = (void (*)(void *)) free_FIX_MidYield;
  cMidYield.trackObjects = 0;
  
  cContractMultiplier.klass = rb_define_class_under(mQuickfix, "ContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContractMultiplier, (void *) &cContractMultiplier);
  rb_define_alloc_func(cContractMultiplier.klass, _wrap_ContractMultiplier_allocate);
  rb_define_method(cContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_ContractMultiplier), -1);
  cContractMultiplier.mark = 0;
  cContractMultiplier.destroy = (void (*)(void *)) free_FIX_ContractMultiplier;
  cContractMultiplier.trackObjects = 0;
  
  cPartyAltIDSource.klass = rb_define_class_under(mQuickfix, "PartyAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyAltIDSource, (void *) &cPartyAltIDSource);
  rb_define_alloc_func(cPartyAltIDSource.klass, _wrap_PartyAltIDSource_allocate);
  rb_define_method(cPartyAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_PartyAltIDSource), -1);
  cPartyAltIDSource.mark = 0;
  cPartyAltIDSource.destroy = (void (*)(void *)) free_FIX_PartyAltIDSource;
  cPartyAltIDSource.trackObjects = 0;
  
  cCcyAmt.klass = rb_define_class_under(mQuickfix, "CcyAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CcyAmt, (void *) &cCcyAmt);
  rb_define_alloc_func(cCcyAmt.klass, _wrap_CcyAmt_allocate);
  rb_define_method(cCcyAmt.klass, "initialize", VALUEFUNC(_wrap_new_CcyAmt), -1);
  cCcyAmt.mark = 0;
  cCcyAmt.destroy = (void (*)(void *)) free_FIX_CcyAmt;
  cCcyAmt.trackObjects = 0;
  
  cAllocIntermedReqType.klass = rb_define_class_under(mQuickfix, "AllocIntermedReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocIntermedReqType, (void *) &cAllocIntermedReqType);
  rb_define_alloc_func(cAllocIntermedReqType.klass, _wrap_AllocIntermedReqType_allocate);
  rb_define_method(cAllocIntermedReqType.klass, "initialize", VALUEFUNC(_wrap_new_AllocIntermedReqType), -1);
  cAllocIntermedReqType.mark = 0;
  cAllocIntermedReqType.destroy = (void (*)(void *)) free_FIX_AllocIntermedReqType;
  cAllocIntermedReqType.trackObjects = 0;
  
  cNoNested2PartyIDs.klass = rb_define_class_under(mQuickfix, "NoNested2PartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested2PartyIDs, (void *) &cNoNested2PartyIDs);
  rb_define_alloc_func(cNoNested2PartyIDs.klass, _wrap_NoNested2PartyIDs_allocate);
  rb_define_method(cNoNested2PartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested2PartyIDs), -1);
  cNoNested2PartyIDs.mark = 0;
  cNoNested2PartyIDs.destroy = (void (*)(void *)) free_FIX_NoNested2PartyIDs;
  cNoNested2PartyIDs.trackObjects = 0;
  
  cUnderlyingIssuer.klass = rb_define_class_under(mQuickfix, "UnderlyingIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingIssuer, (void *) &cUnderlyingIssuer);
  rb_define_alloc_func(cUnderlyingIssuer.klass, _wrap_UnderlyingIssuer_allocate);
  rb_define_method(cUnderlyingIssuer.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingIssuer), -1);
  cUnderlyingIssuer.mark = 0;
  cUnderlyingIssuer.destroy = (void (*)(void *)) free_FIX_UnderlyingIssuer;
  cUnderlyingIssuer.trackObjects = 0;
  
  cLegOrderQty.klass = rb_define_class_under(mQuickfix, "LegOrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOrderQty, (void *) &cLegOrderQty);
  rb_define_alloc_func(cLegOrderQty.klass, _wrap_LegOrderQty_allocate);
  rb_define_method(cLegOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_LegOrderQty), -1);
  cLegOrderQty.mark = 0;
  cLegOrderQty.destroy = (void (*)(void *)) free_FIX_LegOrderQty;
  cLegOrderQty.trackObjects = 0;
  
  cMinTradeVol.klass = rb_define_class_under(mQuickfix, "MinTradeVol", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinTradeVol, (void *) &cMinTradeVol);
  rb_define_alloc_func(cMinTradeVol.klass, _wrap_MinTradeVol_allocate);
  rb_define_method(cMinTradeVol.klass, "initialize", VALUEFUNC(_wrap_new_MinTradeVol), -1);
  cMinTradeVol.mark = 0;
  cMinTradeVol.destroy = (void (*)(void *)) free_FIX_MinTradeVol;
  cMinTradeVol.trackObjects = 0;
  
  cSettlCurrAmt.klass = rb_define_class_under(mQuickfix, "SettlCurrAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrAmt, (void *) &cSettlCurrAmt);
  rb_define_alloc_func(cSettlCurrAmt.klass, _wrap_SettlCurrAmt_allocate);
  rb_define_method(cSettlCurrAmt.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrAmt), -1);
  cSettlCurrAmt.mark = 0;
  cSettlCurrAmt.destroy = (void (*)(void *)) free_FIX_SettlCurrAmt;
  cSettlCurrAmt.trackObjects = 0;
  
  cDerivativeInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyRole, (void *) &cDerivativeInstrumentPartyRole);
  rb_define_alloc_func(cDerivativeInstrumentPartyRole.klass, _wrap_DerivativeInstrumentPartyRole_allocate);
  rb_define_method(cDerivativeInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartyRole), -1);
  cDerivativeInstrumentPartyRole.mark = 0;
  cDerivativeInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartyRole;
  cDerivativeInstrumentPartyRole.trackObjects = 0;
  
  cYieldRedemptionPriceType.klass = rb_define_class_under(mQuickfix, "YieldRedemptionPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldRedemptionPriceType, (void *) &cYieldRedemptionPriceType);
  rb_define_alloc_func(cYieldRedemptionPriceType.klass, _wrap_YieldRedemptionPriceType_allocate);
  rb_define_method(cYieldRedemptionPriceType.klass, "initialize", VALUEFUNC(_wrap_new_YieldRedemptionPriceType), -1);
  cYieldRedemptionPriceType.mark = 0;
  cYieldRedemptionPriceType.destroy = (void (*)(void *)) free_FIX_YieldRedemptionPriceType;
  cYieldRedemptionPriceType.trackObjects = 0;
  
  cNewsRefID.klass = rb_define_class_under(mQuickfix, "NewsRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsRefID, (void *) &cNewsRefID);
  rb_define_alloc_func(cNewsRefID.klass, _wrap_NewsRefID_allocate);
  rb_define_method(cNewsRefID.klass, "initialize", VALUEFUNC(_wrap_new_NewsRefID), -1);
  cNewsRefID.mark = 0;
  cNewsRefID.destroy = (void (*)(void *)) free_FIX_NewsRefID;
  cNewsRefID.trackObjects = 0;
  
  cSecurityListTypeSource.klass = rb_define_class_under(mQuickfix, "SecurityListTypeSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListTypeSource, (void *) &cSecurityListTypeSource);
  rb_define_alloc_func(cSecurityListTypeSource.klass, _wrap_SecurityListTypeSource_allocate);
  rb_define_method(cSecurityListTypeSource.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListTypeSource), -1);
  cSecurityListTypeSource.mark = 0;
  cSecurityListTypeSource.destroy = (void (*)(void *)) free_FIX_SecurityListTypeSource;
  cSecurityListTypeSource.trackObjects = 0;
  
  cApplReqID.klass = rb_define_class_under(mQuickfix, "ApplReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReqID, (void *) &cApplReqID);
  rb_define_alloc_func(cApplReqID.klass, _wrap_ApplReqID_allocate);
  rb_define_method(cApplReqID.klass, "initialize", VALUEFUNC(_wrap_new_ApplReqID), -1);
  cApplReqID.mark = 0;
  cApplReqID.destroy = (void (*)(void *)) free_FIX_ApplReqID;
  cApplReqID.trackObjects = 0;
  
  cDerivativeFuturesValuationMethod.klass = rb_define_class_under(mQuickfix, "DerivativeFuturesValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeFuturesValuationMethod, (void *) &cDerivativeFuturesValuationMethod);
  rb_define_alloc_func(cDerivativeFuturesValuationMethod.klass, _wrap_DerivativeFuturesValuationMethod_allocate);
  rb_define_method(cDerivativeFuturesValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeFuturesValuationMethod), -1);
  cDerivativeFuturesValuationMethod.mark = 0;
  cDerivativeFuturesValuationMethod.destroy = (void (*)(void *)) free_FIX_DerivativeFuturesValuationMethod;
  cDerivativeFuturesValuationMethod.trackObjects = 0;
  
  cNoLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoLegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegSecurityAltID, (void *) &cNoLegSecurityAltID);
  rb_define_alloc_func(cNoLegSecurityAltID.klass, _wrap_NoLegSecurityAltID_allocate);
  rb_define_method(cNoLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoLegSecurityAltID), -1);
  cNoLegSecurityAltID.mark = 0;
  cNoLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoLegSecurityAltID;
  cNoLegSecurityAltID.trackObjects = 0;
  
  cDerivativeSecurityType.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityType, (void *) &cDerivativeSecurityType);
  rb_define_alloc_func(cDerivativeSecurityType.klass, _wrap_DerivativeSecurityType_allocate);
  rb_define_method(cDerivativeSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityType), -1);
  cDerivativeSecurityType.mark = 0;
  cDerivativeSecurityType.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityType;
  cDerivativeSecurityType.trackObjects = 0;
  
  cCollInquiryQualifier.klass = rb_define_class_under(mQuickfix, "CollInquiryQualifier", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryQualifier, (void *) &cCollInquiryQualifier);
  rb_define_alloc_func(cCollInquiryQualifier.klass, _wrap_CollInquiryQualifier_allocate);
  rb_define_method(cCollInquiryQualifier.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryQualifier), -1);
  cCollInquiryQualifier.mark = 0;
  cCollInquiryQualifier.destroy = (void (*)(void *)) free_FIX_CollInquiryQualifier;
  cCollInquiryQualifier.trackObjects = 0;
  
  cRawData.klass = rb_define_class_under(mQuickfix, "RawData", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RawData, (void *) &cRawData);
  rb_define_alloc_func(cRawData.klass, _wrap_RawData_allocate);
  rb_define_method(cRawData.klass, "initialize", VALUEFUNC(_wrap_new_RawData), -1);
  cRawData.mark = 0;
  cRawData.destroy = (void (*)(void *)) free_FIX_RawData;
  cRawData.trackObjects = 0;
  
  cCashSettlAgentContactPhone.klass = rb_define_class_under(mQuickfix, "CashSettlAgentContactPhone", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentContactPhone, (void *) &cCashSettlAgentContactPhone);
  rb_define_alloc_func(cCashSettlAgentContactPhone.klass, _wrap_CashSettlAgentContactPhone_allocate);
  rb_define_method(cCashSettlAgentContactPhone.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentContactPhone), -1);
  cCashSettlAgentContactPhone.mark = 0;
  cCashSettlAgentContactPhone.destroy = (void (*)(void *)) free_FIX_CashSettlAgentContactPhone;
  cCashSettlAgentContactPhone.trackObjects = 0;
  
  cCreditRating.klass = rb_define_class_under(mQuickfix, "CreditRating", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CreditRating, (void *) &cCreditRating);
  rb_define_alloc_func(cCreditRating.klass, _wrap_CreditRating_allocate);
  rb_define_method(cCreditRating.klass, "initialize", VALUEFUNC(_wrap_new_CreditRating), -1);
  cCreditRating.mark = 0;
  cCreditRating.destroy = (void (*)(void *)) free_FIX_CreditRating;
  cCreditRating.trackObjects = 0;
  
  cContingencyType.klass = rb_define_class_under(mQuickfix, "ContingencyType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContingencyType, (void *) &cContingencyType);
  rb_define_alloc_func(cContingencyType.klass, _wrap_ContingencyType_allocate);
  rb_define_method(cContingencyType.klass, "initialize", VALUEFUNC(_wrap_new_ContingencyType), -1);
  cContingencyType.mark = 0;
  cContingencyType.destroy = (void (*)(void *)) free_FIX_ContingencyType;
  cContingencyType.trackObjects = 0;
  
  cStrikeCurrency.klass = rb_define_class_under(mQuickfix, "StrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeCurrency, (void *) &cStrikeCurrency);
  rb_define_alloc_func(cStrikeCurrency.klass, _wrap_StrikeCurrency_allocate);
  rb_define_method(cStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_StrikeCurrency), -1);
  cStrikeCurrency.mark = 0;
  cStrikeCurrency.destroy = (void (*)(void *)) free_FIX_StrikeCurrency;
  cStrikeCurrency.trackObjects = 0;
  
  cTradeVolume.klass = rb_define_class_under(mQuickfix, "TradeVolume", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeVolume, (void *) &cTradeVolume);
  rb_define_alloc_func(cTradeVolume.klass, _wrap_TradeVolume_allocate);
  rb_define_method(cTradeVolume.klass, "initialize", VALUEFUNC(_wrap_new_TradeVolume), -1);
  cTradeVolume.mark = 0;
  cTradeVolume.destroy = (void (*)(void *)) free_FIX_TradeVolume;
  cTradeVolume.trackObjects = 0;
  
  cSideTrdRegTimestampSrc.klass = rb_define_class_under(mQuickfix, "SideTrdRegTimestampSrc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdRegTimestampSrc, (void *) &cSideTrdRegTimestampSrc);
  rb_define_alloc_func(cSideTrdRegTimestampSrc.klass, _wrap_SideTrdRegTimestampSrc_allocate);
  rb_define_method(cSideTrdRegTimestampSrc.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdRegTimestampSrc), -1);
  cSideTrdRegTimestampSrc.mark = 0;
  cSideTrdRegTimestampSrc.destroy = (void (*)(void *)) free_FIX_SideTrdRegTimestampSrc;
  cSideTrdRegTimestampSrc.trackObjects = 0;
  
  cDeliveryDate.klass = rb_define_class_under(mQuickfix, "DeliveryDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliveryDate, (void *) &cDeliveryDate);
  rb_define_alloc_func(cDeliveryDate.klass, _wrap_DeliveryDate_allocate);
  rb_define_method(cDeliveryDate.klass, "initialize", VALUEFUNC(_wrap_new_DeliveryDate), -1);
  cDeliveryDate.mark = 0;
  cDeliveryDate.destroy = (void (*)(void *)) free_FIX_DeliveryDate;
  cDeliveryDate.trackObjects = 0;
  
  cEmailType.klass = rb_define_class_under(mQuickfix, "EmailType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EmailType, (void *) &cEmailType);
  rb_define_alloc_func(cEmailType.klass, _wrap_EmailType_allocate);
  rb_define_method(cEmailType.klass, "initialize", VALUEFUNC(_wrap_new_EmailType), -1);
  cEmailType.mark = 0;
  cEmailType.destroy = (void (*)(void *)) free_FIX_EmailType;
  cEmailType.trackObjects = 0;
  
  cEncodedListExecInst.klass = rb_define_class_under(mQuickfix, "EncodedListExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListExecInst, (void *) &cEncodedListExecInst);
  rb_define_alloc_func(cEncodedListExecInst.klass, _wrap_EncodedListExecInst_allocate);
  rb_define_method(cEncodedListExecInst.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListExecInst), -1);
  cEncodedListExecInst.mark = 0;
  cEncodedListExecInst.destroy = (void (*)(void *)) free_FIX_EncodedListExecInst;
  cEncodedListExecInst.trackObjects = 0;
  
  cContraTradeTime.klass = rb_define_class_under(mQuickfix, "ContraTradeTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraTradeTime, (void *) &cContraTradeTime);
  rb_define_alloc_func(cContraTradeTime.klass, _wrap_ContraTradeTime_allocate);
  rb_define_method(cContraTradeTime.klass, "initialize", VALUEFUNC(_wrap_new_ContraTradeTime), -1);
  cContraTradeTime.mark = 0;
  cContraTradeTime.destroy = (void (*)(void *)) free_FIX_ContraTradeTime;
  cContraTradeTime.trackObjects = 0;
  
  cMaturityMonthYearIncrement.klass = rb_define_class_under(mQuickfix, "MaturityMonthYearIncrement", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYearIncrement, (void *) &cMaturityMonthYearIncrement);
  rb_define_alloc_func(cMaturityMonthYearIncrement.klass, _wrap_MaturityMonthYearIncrement_allocate);
  rb_define_method(cMaturityMonthYearIncrement.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYearIncrement), -1);
  cMaturityMonthYearIncrement.mark = 0;
  cMaturityMonthYearIncrement.destroy = (void (*)(void *)) free_FIX_MaturityMonthYearIncrement;
  cMaturityMonthYearIncrement.trackObjects = 0;
  
  cRootPartyIDSource.klass = rb_define_class_under(mQuickfix, "RootPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartyIDSource, (void *) &cRootPartyIDSource);
  rb_define_alloc_func(cRootPartyIDSource.klass, _wrap_RootPartyIDSource_allocate);
  rb_define_method(cRootPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RootPartyIDSource), -1);
  cRootPartyIDSource.mark = 0;
  cRootPartyIDSource.destroy = (void (*)(void *)) free_FIX_RootPartyIDSource;
  cRootPartyIDSource.trackObjects = 0;
  
  cUnderlyingCouponPaymentDate.klass = rb_define_class_under(mQuickfix, "UnderlyingCouponPaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCouponPaymentDate, (void *) &cUnderlyingCouponPaymentDate);
  rb_define_alloc_func(cUnderlyingCouponPaymentDate.klass, _wrap_UnderlyingCouponPaymentDate_allocate);
  rb_define_method(cUnderlyingCouponPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCouponPaymentDate), -1);
  cUnderlyingCouponPaymentDate.mark = 0;
  cUnderlyingCouponPaymentDate.destroy = (void (*)(void *)) free_FIX_UnderlyingCouponPaymentDate;
  cUnderlyingCouponPaymentDate.trackObjects = 0;
  
  cBidYield.klass = rb_define_class_under(mQuickfix, "BidYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidYield, (void *) &cBidYield);
  rb_define_alloc_func(cBidYield.klass, _wrap_BidYield_allocate);
  rb_define_method(cBidYield.klass, "initialize", VALUEFUNC(_wrap_new_BidYield), -1);
  cBidYield.mark = 0;
  cBidYield.destroy = (void (*)(void *)) free_FIX_BidYield;
  cBidYield.trackObjects = 0;
  
  cIOIQltyInd.klass = rb_define_class_under(mQuickfix, "IOIQltyInd", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIQltyInd, (void *) &cIOIQltyInd);
  rb_define_alloc_func(cIOIQltyInd.klass, _wrap_IOIQltyInd_allocate);
  rb_define_method(cIOIQltyInd.klass, "initialize", VALUEFUNC(_wrap_new_IOIQltyInd), -1);
  cIOIQltyInd.mark = 0;
  cIOIQltyInd.destroy = (void (*)(void *)) free_FIX_IOIQltyInd;
  cIOIQltyInd.trackObjects = 0;
  
  cIssuer.klass = rb_define_class_under(mQuickfix, "Issuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Issuer, (void *) &cIssuer);
  rb_define_alloc_func(cIssuer.klass, _wrap_Issuer_allocate);
  rb_define_method(cIssuer.klass, "initialize", VALUEFUNC(_wrap_new_Issuer), -1);
  cIssuer.mark = 0;
  cIssuer.destroy = (void (*)(void *)) free_FIX_Issuer;
  cIssuer.trackObjects = 0;
  
  cCardNumber.klass = rb_define_class_under(mQuickfix, "CardNumber", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardNumber, (void *) &cCardNumber);
  rb_define_alloc_func(cCardNumber.klass, _wrap_CardNumber_allocate);
  rb_define_method(cCardNumber.klass, "initialize", VALUEFUNC(_wrap_new_CardNumber), -1);
  cCardNumber.mark = 0;
  cCardNumber.destroy = (void (*)(void *)) free_FIX_CardNumber;
  cCardNumber.trackObjects = 0;
  
  cNoRelatedPartyIDs.klass = rb_define_class_under(mQuickfix, "NoRelatedPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedPartyIDs, (void *) &cNoRelatedPartyIDs);
  rb_define_alloc_func(cNoRelatedPartyIDs.klass, _wrap_NoRelatedPartyIDs_allocate);
  rb_define_method(cNoRelatedPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedPartyIDs), -1);
  cNoRelatedPartyIDs.mark = 0;
  cNoRelatedPartyIDs.destroy = (void (*)(void *)) free_FIX_NoRelatedPartyIDs;
  cNoRelatedPartyIDs.trackObjects = 0;
  
  cNoLegStipulations.klass = rb_define_class_under(mQuickfix, "NoLegStipulations", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegStipulations, (void *) &cNoLegStipulations);
  rb_define_alloc_func(cNoLegStipulations.klass, _wrap_NoLegStipulations_allocate);
  rb_define_method(cNoLegStipulations.klass, "initialize", VALUEFUNC(_wrap_new_NoLegStipulations), -1);
  cNoLegStipulations.mark = 0;
  cNoLegStipulations.destroy = (void (*)(void *)) free_FIX_NoLegStipulations;
  cNoLegStipulations.trackObjects = 0;
  
  cLegSecurityExchange.klass = rb_define_class_under(mQuickfix, "LegSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityExchange, (void *) &cLegSecurityExchange);
  rb_define_alloc_func(cLegSecurityExchange.klass, _wrap_LegSecurityExchange_allocate);
  rb_define_method(cLegSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityExchange), -1);
  cLegSecurityExchange.mark = 0;
  cLegSecurityExchange.destroy = (void (*)(void *)) free_FIX_LegSecurityExchange;
  cLegSecurityExchange.trackObjects = 0;
  
  cCashOrderQty.klass = rb_define_class_under(mQuickfix, "CashOrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashOrderQty, (void *) &cCashOrderQty);
  rb_define_alloc_func(cCashOrderQty.klass, _wrap_CashOrderQty_allocate);
  rb_define_method(cCashOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_CashOrderQty), -1);
  cCashOrderQty.mark = 0;
  cCashOrderQty.destroy = (void (*)(void *)) free_FIX_CashOrderQty;
  cCashOrderQty.trackObjects = 0;
  
  cAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "AccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AccruedInterestAmt, (void *) &cAccruedInterestAmt);
  rb_define_alloc_func(cAccruedInterestAmt.klass, _wrap_AccruedInterestAmt_allocate);
  rb_define_method(cAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_AccruedInterestAmt), -1);
  cAccruedInterestAmt.mark = 0;
  cAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_AccruedInterestAmt;
  cAccruedInterestAmt.trackObjects = 0;
  
  cMDEntrySeller.klass = rb_define_class_under(mQuickfix, "MDEntrySeller", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntrySeller, (void *) &cMDEntrySeller);
  rb_define_alloc_func(cMDEntrySeller.klass, _wrap_MDEntrySeller_allocate);
  rb_define_method(cMDEntrySeller.klass, "initialize", VALUEFUNC(_wrap_new_MDEntrySeller), -1);
  cMDEntrySeller.mark = 0;
  cMDEntrySeller.destroy = (void (*)(void *)) free_FIX_MDEntrySeller;
  cMDEntrySeller.trackObjects = 0;
  
  cLegPrice.klass = rb_define_class_under(mQuickfix, "LegPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPrice, (void *) &cLegPrice);
  rb_define_alloc_func(cLegPrice.klass, _wrap_LegPrice_allocate);
  rb_define_method(cLegPrice.klass, "initialize", VALUEFUNC(_wrap_new_LegPrice), -1);
  cLegPrice.mark = 0;
  cLegPrice.destroy = (void (*)(void *)) free_FIX_LegPrice;
  cLegPrice.trackObjects = 0;
  
  cRelationshipRiskMaturityTime.klass = rb_define_class_under(mQuickfix, "RelationshipRiskMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskMaturityTime, (void *) &cRelationshipRiskMaturityTime);
  rb_define_alloc_func(cRelationshipRiskMaturityTime.klass, _wrap_RelationshipRiskMaturityTime_allocate);
  rb_define_method(cRelationshipRiskMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskMaturityTime), -1);
  cRelationshipRiskMaturityTime.mark = 0;
  cRelationshipRiskMaturityTime.destroy = (void (*)(void *)) free_FIX_RelationshipRiskMaturityTime;
  cRelationshipRiskMaturityTime.trackObjects = 0;
  
  cDeliverToCompID.klass = rb_define_class_under(mQuickfix, "DeliverToCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliverToCompID, (void *) &cDeliverToCompID);
  rb_define_alloc_func(cDeliverToCompID.klass, _wrap_DeliverToCompID_allocate);
  rb_define_method(cDeliverToCompID.klass, "initialize", VALUEFUNC(_wrap_new_DeliverToCompID), -1);
  cDeliverToCompID.mark = 0;
  cDeliverToCompID.destroy = (void (*)(void *)) free_FIX_DeliverToCompID;
  cDeliverToCompID.trackObjects = 0;
  
  cTargetLocationID.klass = rb_define_class_under(mQuickfix, "TargetLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetLocationID, (void *) &cTargetLocationID);
  rb_define_alloc_func(cTargetLocationID.klass, _wrap_TargetLocationID_allocate);
  rb_define_method(cTargetLocationID.klass, "initialize", VALUEFUNC(_wrap_new_TargetLocationID), -1);
  cTargetLocationID.mark = 0;
  cTargetLocationID.destroy = (void (*)(void *)) free_FIX_TargetLocationID;
  cTargetLocationID.trackObjects = 0;
  
  cOfferForwardPoints2.klass = rb_define_class_under(mQuickfix, "OfferForwardPoints2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferForwardPoints2, (void *) &cOfferForwardPoints2);
  rb_define_alloc_func(cOfferForwardPoints2.klass, _wrap_OfferForwardPoints2_allocate);
  rb_define_method(cOfferForwardPoints2.klass, "initialize", VALUEFUNC(_wrap_new_OfferForwardPoints2), -1);
  cOfferForwardPoints2.mark = 0;
  cOfferForwardPoints2.destroy = (void (*)(void *)) free_FIX_OfferForwardPoints2;
  cOfferForwardPoints2.trackObjects = 0;
  
  cRatioQty.klass = rb_define_class_under(mQuickfix, "RatioQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RatioQty, (void *) &cRatioQty);
  rb_define_alloc_func(cRatioQty.klass, _wrap_RatioQty_allocate);
  rb_define_method(cRatioQty.klass, "initialize", VALUEFUNC(_wrap_new_RatioQty), -1);
  cRatioQty.mark = 0;
  cRatioQty.destroy = (void (*)(void *)) free_FIX_RatioQty;
  cRatioQty.trackObjects = 0;
  
  cMultiLegRptTypeReq.klass = rb_define_class_under(mQuickfix, "MultiLegRptTypeReq", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultiLegRptTypeReq, (void *) &cMultiLegRptTypeReq);
  rb_define_alloc_func(cMultiLegRptTypeReq.klass, _wrap_MultiLegRptTypeReq_allocate);
  rb_define_method(cMultiLegRptTypeReq.klass, "initialize", VALUEFUNC(_wrap_new_MultiLegRptTypeReq), -1);
  cMultiLegRptTypeReq.mark = 0;
  cMultiLegRptTypeReq.destroy = (void (*)(void *)) free_FIX_MultiLegRptTypeReq;
  cMultiLegRptTypeReq.trackObjects = 0;
  
  cAllocAccount.klass = rb_define_class_under(mQuickfix, "AllocAccount", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAccount, (void *) &cAllocAccount);
  rb_define_alloc_func(cAllocAccount.klass, _wrap_AllocAccount_allocate);
  rb_define_method(cAllocAccount.klass, "initialize", VALUEFUNC(_wrap_new_AllocAccount), -1);
  cAllocAccount.mark = 0;
  cAllocAccount.destroy = (void (*)(void *)) free_FIX_AllocAccount;
  cAllocAccount.trackObjects = 0;
  
  cTotalVolumeTraded.klass = rb_define_class_under(mQuickfix, "TotalVolumeTraded", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalVolumeTraded, (void *) &cTotalVolumeTraded);
  rb_define_alloc_func(cTotalVolumeTraded.klass, _wrap_TotalVolumeTraded_allocate);
  rb_define_method(cTotalVolumeTraded.klass, "initialize", VALUEFUNC(_wrap_new_TotalVolumeTraded), -1);
  cTotalVolumeTraded.mark = 0;
  cTotalVolumeTraded.destroy = (void (*)(void *)) free_FIX_TotalVolumeTraded;
  cTotalVolumeTraded.trackObjects = 0;
  
  cLinesOfText.klass = rb_define_class_under(mQuickfix, "LinesOfText", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LinesOfText, (void *) &cLinesOfText);
  rb_define_alloc_func(cLinesOfText.klass, _wrap_LinesOfText_allocate);
  rb_define_method(cLinesOfText.klass, "initialize", VALUEFUNC(_wrap_new_LinesOfText), -1);
  cLinesOfText.mark = 0;
  cLinesOfText.destroy = (void (*)(void *)) free_FIX_LinesOfText;
  cLinesOfText.trackObjects = 0;
  
  cAccountType.klass = rb_define_class_under(mQuickfix, "AccountType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AccountType, (void *) &cAccountType);
  rb_define_alloc_func(cAccountType.klass, _wrap_AccountType_allocate);
  rb_define_method(cAccountType.klass, "initialize", VALUEFUNC(_wrap_new_AccountType), -1);
  cAccountType.mark = 0;
  cAccountType.destroy = (void (*)(void *)) free_FIX_AccountType;
  cAccountType.trackObjects = 0;
  
  cMDEntryPositionNo.klass = rb_define_class_under(mQuickfix, "MDEntryPositionNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryPositionNo, (void *) &cMDEntryPositionNo);
  rb_define_alloc_func(cMDEntryPositionNo.klass, _wrap_MDEntryPositionNo_allocate);
  rb_define_method(cMDEntryPositionNo.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryPositionNo), -1);
  cMDEntryPositionNo.mark = 0;
  cMDEntryPositionNo.destroy = (void (*)(void *)) free_FIX_MDEntryPositionNo;
  cMDEntryPositionNo.trackObjects = 0;
  
  cHaltReasonInt.klass = rb_define_class_under(mQuickfix, "HaltReasonInt", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HaltReasonInt, (void *) &cHaltReasonInt);
  rb_define_alloc_func(cHaltReasonInt.klass, _wrap_HaltReasonInt_allocate);
  rb_define_method(cHaltReasonInt.klass, "initialize", VALUEFUNC(_wrap_new_HaltReasonInt), -1);
  cHaltReasonInt.mark = 0;
  cHaltReasonInt.destroy = (void (*)(void *)) free_FIX_HaltReasonInt;
  cHaltReasonInt.trackObjects = 0;
  
  cFutSettDate.klass = rb_define_class_under(mQuickfix, "FutSettDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FutSettDate, (void *) &cFutSettDate);
  rb_define_alloc_func(cFutSettDate.klass, _wrap_FutSettDate_allocate);
  rb_define_method(cFutSettDate.klass, "initialize", VALUEFUNC(_wrap_new_FutSettDate), -1);
  cFutSettDate.mark = 0;
  cFutSettDate.destroy = (void (*)(void *)) free_FIX_FutSettDate;
  cFutSettDate.trackObjects = 0;
  
  cSecurityDesc.klass = rb_define_class_under(mQuickfix, "SecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityDesc, (void *) &cSecurityDesc);
  rb_define_alloc_func(cSecurityDesc.klass, _wrap_SecurityDesc_allocate);
  rb_define_method(cSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_SecurityDesc), -1);
  cSecurityDesc.mark = 0;
  cSecurityDesc.destroy = (void (*)(void *)) free_FIX_SecurityDesc;
  cSecurityDesc.trackObjects = 0;
  
  cMinQty.klass = rb_define_class_under(mQuickfix, "MinQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinQty, (void *) &cMinQty);
  rb_define_alloc_func(cMinQty.klass, _wrap_MinQty_allocate);
  rb_define_method(cMinQty.klass, "initialize", VALUEFUNC(_wrap_new_MinQty), -1);
  cMinQty.mark = 0;
  cMinQty.destroy = (void (*)(void *)) free_FIX_MinQty;
  cMinQty.trackObjects = 0;
  
  cSettlCurrency.klass = rb_define_class_under(mQuickfix, "SettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrency, (void *) &cSettlCurrency);
  rb_define_alloc_func(cSettlCurrency.klass, _wrap_SettlCurrency_allocate);
  rb_define_method(cSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrency), -1);
  cSettlCurrency.mark = 0;
  cSettlCurrency.destroy = (void (*)(void *)) free_FIX_SettlCurrency;
  cSettlCurrency.trackObjects = 0;
  
  cPegOffsetValue.klass = rb_define_class_under(mQuickfix, "PegOffsetValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegOffsetValue, (void *) &cPegOffsetValue);
  rb_define_alloc_func(cPegOffsetValue.klass, _wrap_PegOffsetValue_allocate);
  rb_define_method(cPegOffsetValue.klass, "initialize", VALUEFUNC(_wrap_new_PegOffsetValue), -1);
  cPegOffsetValue.mark = 0;
  cPegOffsetValue.destroy = (void (*)(void *)) free_FIX_PegOffsetValue;
  cPegOffsetValue.trackObjects = 0;
  
  cDerivativeSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityAltIDSource, (void *) &cDerivativeSecurityAltIDSource);
  rb_define_alloc_func(cDerivativeSecurityAltIDSource.klass, _wrap_DerivativeSecurityAltIDSource_allocate);
  rb_define_method(cDerivativeSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityAltIDSource), -1);
  cDerivativeSecurityAltIDSource.mark = 0;
  cDerivativeSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityAltIDSource;
  cDerivativeSecurityAltIDSource.trackObjects = 0;
  
  cNoSettlPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoSettlPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlPartySubIDs, (void *) &cNoSettlPartySubIDs);
  rb_define_alloc_func(cNoSettlPartySubIDs.klass, _wrap_NoSettlPartySubIDs_allocate);
  rb_define_method(cNoSettlPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlPartySubIDs), -1);
  cNoSettlPartySubIDs.mark = 0;
  cNoSettlPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoSettlPartySubIDs;
  cNoSettlPartySubIDs.trackObjects = 0;
  
  cAllocReportID.klass = rb_define_class_under(mQuickfix, "AllocReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocReportID, (void *) &cAllocReportID);
  rb_define_alloc_func(cAllocReportID.klass, _wrap_AllocReportID_allocate);
  rb_define_method(cAllocReportID.klass, "initialize", VALUEFUNC(_wrap_new_AllocReportID), -1);
  cAllocReportID.mark = 0;
  cAllocReportID.destroy = (void (*)(void *)) free_FIX_AllocReportID;
  cAllocReportID.trackObjects = 0;
  
  cLegCFICode.klass = rb_define_class_under(mQuickfix, "LegCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCFICode, (void *) &cLegCFICode);
  rb_define_alloc_func(cLegCFICode.klass, _wrap_LegCFICode_allocate);
  rb_define_method(cLegCFICode.klass, "initialize", VALUEFUNC(_wrap_new_LegCFICode), -1);
  cLegCFICode.mark = 0;
  cLegCFICode.destroy = (void (*)(void *)) free_FIX_LegCFICode;
  cLegCFICode.trackObjects = 0;
  
  cLegFutSettDate.klass = rb_define_class_under(mQuickfix, "LegFutSettDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegFutSettDate, (void *) &cLegFutSettDate);
  rb_define_alloc_func(cLegFutSettDate.klass, _wrap_LegFutSettDate_allocate);
  rb_define_method(cLegFutSettDate.klass, "initialize", VALUEFUNC(_wrap_new_LegFutSettDate), -1);
  cLegFutSettDate.mark = 0;
  cLegFutSettDate.destroy = (void (*)(void *)) free_FIX_LegFutSettDate;
  cLegFutSettDate.trackObjects = 0;
  
  cLegBenchmarkCurveName.klass = rb_define_class_under(mQuickfix, "LegBenchmarkCurveName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkCurveName, (void *) &cLegBenchmarkCurveName);
  rb_define_alloc_func(cLegBenchmarkCurveName.klass, _wrap_LegBenchmarkCurveName_allocate);
  rb_define_method(cLegBenchmarkCurveName.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkCurveName), -1);
  cLegBenchmarkCurveName.mark = 0;
  cLegBenchmarkCurveName.destroy = (void (*)(void *)) free_FIX_LegBenchmarkCurveName;
  cLegBenchmarkCurveName.trackObjects = 0;
  
  cClearingFeeIndicator.klass = rb_define_class_under(mQuickfix, "ClearingFeeIndicator", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingFeeIndicator, (void *) &cClearingFeeIndicator);
  rb_define_alloc_func(cClearingFeeIndicator.klass, _wrap_ClearingFeeIndicator_allocate);
  rb_define_method(cClearingFeeIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ClearingFeeIndicator), -1);
  cClearingFeeIndicator.mark = 0;
  cClearingFeeIndicator.destroy = (void (*)(void *)) free_FIX_ClearingFeeIndicator;
  cClearingFeeIndicator.trackObjects = 0;
  
  cBrokerOfCredit.klass = rb_define_class_under(mQuickfix, "BrokerOfCredit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BrokerOfCredit, (void *) &cBrokerOfCredit);
  rb_define_alloc_func(cBrokerOfCredit.klass, _wrap_BrokerOfCredit_allocate);
  rb_define_method(cBrokerOfCredit.klass, "initialize", VALUEFUNC(_wrap_new_BrokerOfCredit), -1);
  cBrokerOfCredit.mark = 0;
  cBrokerOfCredit.destroy = (void (*)(void *)) free_FIX_BrokerOfCredit;
  cBrokerOfCredit.trackObjects = 0;
  
  cSecurityListRefID.klass = rb_define_class_under(mQuickfix, "SecurityListRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListRefID, (void *) &cSecurityListRefID);
  rb_define_alloc_func(cSecurityListRefID.klass, _wrap_SecurityListRefID_allocate);
  rb_define_method(cSecurityListRefID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListRefID), -1);
  cSecurityListRefID.mark = 0;
  cSecurityListRefID.destroy = (void (*)(void *)) free_FIX_SecurityListRefID;
  cSecurityListRefID.trackObjects = 0;
  
  cUnderlyingLegMaturityTime.klass = rb_define_class_under(mQuickfix, "UnderlyingLegMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegMaturityTime, (void *) &cUnderlyingLegMaturityTime);
  rb_define_alloc_func(cUnderlyingLegMaturityTime.klass, _wrap_UnderlyingLegMaturityTime_allocate);
  rb_define_method(cUnderlyingLegMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegMaturityTime), -1);
  cUnderlyingLegMaturityTime.mark = 0;
  cUnderlyingLegMaturityTime.destroy = (void (*)(void *)) free_FIX_UnderlyingLegMaturityTime;
  cUnderlyingLegMaturityTime.trackObjects = 0;
  
  cNestedPartySubIDType.klass = rb_define_class_under(mQuickfix, "NestedPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartySubIDType, (void *) &cNestedPartySubIDType);
  rb_define_alloc_func(cNestedPartySubIDType.klass, _wrap_NestedPartySubIDType_allocate);
  rb_define_method(cNestedPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartySubIDType), -1);
  cNestedPartySubIDType.mark = 0;
  cNestedPartySubIDType.destroy = (void (*)(void *)) free_FIX_NestedPartySubIDType;
  cNestedPartySubIDType.trackObjects = 0;
  
  cBidType.klass = rb_define_class_under(mQuickfix, "BidType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidType, (void *) &cBidType);
  rb_define_alloc_func(cBidType.klass, _wrap_BidType_allocate);
  rb_define_method(cBidType.klass, "initialize", VALUEFUNC(_wrap_new_BidType), -1);
  cBidType.mark = 0;
  cBidType.destroy = (void (*)(void *)) free_FIX_BidType;
  cBidType.trackObjects = 0;
  
  cMDEntryRefID.klass = rb_define_class_under(mQuickfix, "MDEntryRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryRefID, (void *) &cMDEntryRefID);
  rb_define_alloc_func(cMDEntryRefID.klass, _wrap_MDEntryRefID_allocate);
  rb_define_method(cMDEntryRefID.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryRefID), -1);
  cMDEntryRefID.mark = 0;
  cMDEntryRefID.destroy = (void (*)(void *)) free_FIX_MDEntryRefID;
  cMDEntryRefID.trackObjects = 0;
  
  cUnderlyingUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "UnderlyingUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingUnitOfMeasureQty, (void *) &cUnderlyingUnitOfMeasureQty);
  rb_define_alloc_func(cUnderlyingUnitOfMeasureQty.klass, _wrap_UnderlyingUnitOfMeasureQty_allocate);
  rb_define_method(cUnderlyingUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingUnitOfMeasureQty), -1);
  cUnderlyingUnitOfMeasureQty.mark = 0;
  cUnderlyingUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_UnderlyingUnitOfMeasureQty;
  cUnderlyingUnitOfMeasureQty.trackObjects = 0;
  
  cUnderlyingLegMaturityDate.klass = rb_define_class_under(mQuickfix, "UnderlyingLegMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegMaturityDate, (void *) &cUnderlyingLegMaturityDate);
  rb_define_alloc_func(cUnderlyingLegMaturityDate.klass, _wrap_UnderlyingLegMaturityDate_allocate);
  rb_define_method(cUnderlyingLegMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegMaturityDate), -1);
  cUnderlyingLegMaturityDate.mark = 0;
  cUnderlyingLegMaturityDate.destroy = (void (*)(void *)) free_FIX_UnderlyingLegMaturityDate;
  cUnderlyingLegMaturityDate.trackObjects = 0;
  
  cStartTickPriceRange.klass = rb_define_class_under(mQuickfix, "StartTickPriceRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartTickPriceRange, (void *) &cStartTickPriceRange);
  rb_define_alloc_func(cStartTickPriceRange.klass, _wrap_StartTickPriceRange_allocate);
  rb_define_method(cStartTickPriceRange.klass, "initialize", VALUEFUNC(_wrap_new_StartTickPriceRange), -1);
  cStartTickPriceRange.mark = 0;
  cStartTickPriceRange.destroy = (void (*)(void *)) free_FIX_StartTickPriceRange;
  cStartTickPriceRange.trackObjects = 0;
  
  cLegContractSettlMonth.klass = rb_define_class_under(mQuickfix, "LegContractSettlMonth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegContractSettlMonth, (void *) &cLegContractSettlMonth);
  rb_define_alloc_func(cLegContractSettlMonth.klass, _wrap_LegContractSettlMonth_allocate);
  rb_define_method(cLegContractSettlMonth.klass, "initialize", VALUEFUNC(_wrap_new_LegContractSettlMonth), -1);
  cLegContractSettlMonth.mark = 0;
  cLegContractSettlMonth.destroy = (void (*)(void *)) free_FIX_LegContractSettlMonth;
  cLegContractSettlMonth.trackObjects = 0;
  
  cUnderlyingSecurityDesc.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityDesc, (void *) &cUnderlyingSecurityDesc);
  rb_define_alloc_func(cUnderlyingSecurityDesc.klass, _wrap_UnderlyingSecurityDesc_allocate);
  rb_define_method(cUnderlyingSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityDesc), -1);
  cUnderlyingSecurityDesc.mark = 0;
  cUnderlyingSecurityDesc.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityDesc;
  cUnderlyingSecurityDesc.trackObjects = 0;
  
  cCashDistribPayRef.klass = rb_define_class_under(mQuickfix, "CashDistribPayRef", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribPayRef, (void *) &cCashDistribPayRef);
  rb_define_alloc_func(cCashDistribPayRef.klass, _wrap_CashDistribPayRef_allocate);
  rb_define_method(cCashDistribPayRef.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribPayRef), -1);
  cCashDistribPayRef.mark = 0;
  cCashDistribPayRef.destroy = (void (*)(void *)) free_FIX_CashDistribPayRef;
  cCashDistribPayRef.trackObjects = 0;
  
  cQuotePriceType.klass = rb_define_class_under(mQuickfix, "QuotePriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuotePriceType, (void *) &cQuotePriceType);
  rb_define_alloc_func(cQuotePriceType.klass, _wrap_QuotePriceType_allocate);
  rb_define_method(cQuotePriceType.klass, "initialize", VALUEFUNC(_wrap_new_QuotePriceType), -1);
  cQuotePriceType.mark = 0;
  cQuotePriceType.destroy = (void (*)(void *)) free_FIX_QuotePriceType;
  cQuotePriceType.trackObjects = 0;
  
  cEncodedAllocText.klass = rb_define_class_under(mQuickfix, "EncodedAllocText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedAllocText, (void *) &cEncodedAllocText);
  rb_define_alloc_func(cEncodedAllocText.klass, _wrap_EncodedAllocText_allocate);
  rb_define_method(cEncodedAllocText.klass, "initialize", VALUEFUNC(_wrap_new_EncodedAllocText), -1);
  cEncodedAllocText.mark = 0;
  cEncodedAllocText.destroy = (void (*)(void *)) free_FIX_EncodedAllocText;
  cEncodedAllocText.trackObjects = 0;
  
  cUnderlyingMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityMonthYear, (void *) &cUnderlyingMaturityMonthYear);
  rb_define_alloc_func(cUnderlyingMaturityMonthYear.klass, _wrap_UnderlyingMaturityMonthYear_allocate);
  rb_define_method(cUnderlyingMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityMonthYear), -1);
  cUnderlyingMaturityMonthYear.mark = 0;
  cUnderlyingMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityMonthYear;
  cUnderlyingMaturityMonthYear.trackObjects = 0;
  
  cRiskWarningLevelPercent.klass = rb_define_class_under(mQuickfix, "RiskWarningLevelPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskWarningLevelPercent, (void *) &cRiskWarningLevelPercent);
  rb_define_alloc_func(cRiskWarningLevelPercent.klass, _wrap_RiskWarningLevelPercent_allocate);
  rb_define_method(cRiskWarningLevelPercent.klass, "initialize", VALUEFUNC(_wrap_new_RiskWarningLevelPercent), -1);
  cRiskWarningLevelPercent.mark = 0;
  cRiskWarningLevelPercent.destroy = (void (*)(void *)) free_FIX_RiskWarningLevelPercent;
  cRiskWarningLevelPercent.trackObjects = 0;
  
  cUnderlyingOriginalNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "UnderlyingOriginalNotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, (void *) &cUnderlyingOriginalNotionalPercentageOutstanding);
  rb_define_alloc_func(cUnderlyingOriginalNotionalPercentageOutstanding.klass, _wrap_UnderlyingOriginalNotionalPercentageOutstanding_allocate);
  rb_define_method(cUnderlyingOriginalNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding), -1);
  cUnderlyingOriginalNotionalPercentageOutstanding.mark = 0;
  cUnderlyingOriginalNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_UnderlyingOriginalNotionalPercentageOutstanding;
  cUnderlyingOriginalNotionalPercentageOutstanding.trackObjects = 0;
  
  cMultilegPriceMethod.klass = rb_define_class_under(mQuickfix, "MultilegPriceMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultilegPriceMethod, (void *) &cMultilegPriceMethod);
  rb_define_alloc_func(cMultilegPriceMethod.klass, _wrap_MultilegPriceMethod_allocate);
  rb_define_method(cMultilegPriceMethod.klass, "initialize", VALUEFUNC(_wrap_new_MultilegPriceMethod), -1);
  cMultilegPriceMethod.mark = 0;
  cMultilegPriceMethod.destroy = (void (*)(void *)) free_FIX_MultilegPriceMethod;
  cMultilegPriceMethod.trackObjects = 0;
  
  cTotNoFills.klass = rb_define_class_under(mQuickfix, "TotNoFills", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoFills, (void *) &cTotNoFills);
  rb_define_alloc_func(cTotNoFills.klass, _wrap_TotNoFills_allocate);
  rb_define_method(cTotNoFills.klass, "initialize", VALUEFUNC(_wrap_new_TotNoFills), -1);
  cTotNoFills.mark = 0;
  cTotNoFills.destroy = (void (*)(void *)) free_FIX_TotNoFills;
  cTotNoFills.trackObjects = 0;
  
  cDerivativeSettleOnOpenFlag.klass = rb_define_class_under(mQuickfix, "DerivativeSettleOnOpenFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSettleOnOpenFlag, (void *) &cDerivativeSettleOnOpenFlag);
  rb_define_alloc_func(cDerivativeSettleOnOpenFlag.klass, _wrap_DerivativeSettleOnOpenFlag_allocate);
  rb_define_method(cDerivativeSettleOnOpenFlag.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSettleOnOpenFlag), -1);
  cDerivativeSettleOnOpenFlag.mark = 0;
  cDerivativeSettleOnOpenFlag.destroy = (void (*)(void *)) free_FIX_DerivativeSettleOnOpenFlag;
  cDerivativeSettleOnOpenFlag.trackObjects = 0;
  
  cUnderlyingRepurchaseTerm.klass = rb_define_class_under(mQuickfix, "UnderlyingRepurchaseTerm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRepurchaseTerm, (void *) &cUnderlyingRepurchaseTerm);
  rb_define_alloc_func(cUnderlyingRepurchaseTerm.klass, _wrap_UnderlyingRepurchaseTerm_allocate);
  rb_define_method(cUnderlyingRepurchaseTerm.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRepurchaseTerm), -1);
  cUnderlyingRepurchaseTerm.mark = 0;
  cUnderlyingRepurchaseTerm.destroy = (void (*)(void *)) free_FIX_UnderlyingRepurchaseTerm;
  cUnderlyingRepurchaseTerm.trackObjects = 0;
  
  cRiskWarningLevelName.klass = rb_define_class_under(mQuickfix, "RiskWarningLevelName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskWarningLevelName, (void *) &cRiskWarningLevelName);
  rb_define_alloc_func(cRiskWarningLevelName.klass, _wrap_RiskWarningLevelName_allocate);
  rb_define_method(cRiskWarningLevelName.klass, "initialize", VALUEFUNC(_wrap_new_RiskWarningLevelName), -1);
  cRiskWarningLevelName.mark = 0;
  cRiskWarningLevelName.destroy = (void (*)(void *)) free_FIX_RiskWarningLevelName;
  cRiskWarningLevelName.trackObjects = 0;
  
  cDerivativeCountryOfIssue.klass = rb_define_class_under(mQuickfix, "DerivativeCountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeCountryOfIssue, (void *) &cDerivativeCountryOfIssue);
  rb_define_alloc_func(cDerivativeCountryOfIssue.klass, _wrap_DerivativeCountryOfIssue_allocate);
  rb_define_method(cDerivativeCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeCountryOfIssue), -1);
  cDerivativeCountryOfIssue.mark = 0;
  cDerivativeCountryOfIssue.destroy = (void (*)(void *)) free_FIX_DerivativeCountryOfIssue;
  cDerivativeCountryOfIssue.trackObjects = 0;
  
  cListMethod.klass = rb_define_class_under(mQuickfix, "ListMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListMethod, (void *) &cListMethod);
  rb_define_alloc_func(cListMethod.klass, _wrap_ListMethod_allocate);
  rb_define_method(cListMethod.klass, "initialize", VALUEFUNC(_wrap_new_ListMethod), -1);
  cListMethod.mark = 0;
  cListMethod.destroy = (void (*)(void *)) free_FIX_ListMethod;
  cListMethod.trackObjects = 0;
  
  cUnderlyingCPProgram.klass = rb_define_class_under(mQuickfix, "UnderlyingCPProgram", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCPProgram, (void *) &cUnderlyingCPProgram);
  rb_define_alloc_func(cUnderlyingCPProgram.klass, _wrap_UnderlyingCPProgram_allocate);
  rb_define_method(cUnderlyingCPProgram.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCPProgram), -1);
  cUnderlyingCPProgram.mark = 0;
  cUnderlyingCPProgram.destroy = (void (*)(void *)) free_FIX_UnderlyingCPProgram;
  cUnderlyingCPProgram.trackObjects = 0;
  
  cPriceDelta.klass = rb_define_class_under(mQuickfix, "PriceDelta", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceDelta, (void *) &cPriceDelta);
  rb_define_alloc_func(cPriceDelta.klass, _wrap_PriceDelta_allocate);
  rb_define_method(cPriceDelta.klass, "initialize", VALUEFUNC(_wrap_new_PriceDelta), -1);
  cPriceDelta.mark = 0;
  cPriceDelta.destroy = (void (*)(void *)) free_FIX_PriceDelta;
  cPriceDelta.trackObjects = 0;
  
  cRefSeqNum.klass = rb_define_class_under(mQuickfix, "RefSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefSeqNum, (void *) &cRefSeqNum);
  rb_define_alloc_func(cRefSeqNum.klass, _wrap_RefSeqNum_allocate);
  rb_define_method(cRefSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_RefSeqNum), -1);
  cRefSeqNum.mark = 0;
  cRefSeqNum.destroy = (void (*)(void *)) free_FIX_RefSeqNum;
  cRefSeqNum.trackObjects = 0;
  
  cAutoAcceptIndicator.klass = rb_define_class_under(mQuickfix, "AutoAcceptIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AutoAcceptIndicator, (void *) &cAutoAcceptIndicator);
  rb_define_alloc_func(cAutoAcceptIndicator.klass, _wrap_AutoAcceptIndicator_allocate);
  rb_define_method(cAutoAcceptIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AutoAcceptIndicator), -1);
  cAutoAcceptIndicator.mark = 0;
  cAutoAcceptIndicator.destroy = (void (*)(void *)) free_FIX_AutoAcceptIndicator;
  cAutoAcceptIndicator.trackObjects = 0;
  
  cMDImplicitDelete.klass = rb_define_class_under(mQuickfix, "MDImplicitDelete", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDImplicitDelete, (void *) &cMDImplicitDelete);
  rb_define_alloc_func(cMDImplicitDelete.klass, _wrap_MDImplicitDelete_allocate);
  rb_define_method(cMDImplicitDelete.klass, "initialize", VALUEFUNC(_wrap_new_MDImplicitDelete), -1);
  cMDImplicitDelete.mark = 0;
  cMDImplicitDelete.destroy = (void (*)(void *)) free_FIX_MDImplicitDelete;
  cMDImplicitDelete.trackObjects = 0;
  
  cNoStipulations.klass = rb_define_class_under(mQuickfix, "NoStipulations", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStipulations, (void *) &cNoStipulations);
  rb_define_alloc_func(cNoStipulations.klass, _wrap_NoStipulations_allocate);
  rb_define_method(cNoStipulations.klass, "initialize", VALUEFUNC(_wrap_new_NoStipulations), -1);
  cNoStipulations.mark = 0;
  cNoStipulations.destroy = (void (*)(void *)) free_FIX_NoStipulations;
  cNoStipulations.trackObjects = 0;
  
  cClearingBusinessDate.klass = rb_define_class_under(mQuickfix, "ClearingBusinessDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingBusinessDate, (void *) &cClearingBusinessDate);
  rb_define_alloc_func(cClearingBusinessDate.klass, _wrap_ClearingBusinessDate_allocate);
  rb_define_method(cClearingBusinessDate.klass, "initialize", VALUEFUNC(_wrap_new_ClearingBusinessDate), -1);
  cClearingBusinessDate.mark = 0;
  cClearingBusinessDate.destroy = (void (*)(void *)) free_FIX_ClearingBusinessDate;
  cClearingBusinessDate.trackObjects = 0;
  
  cNoRelationshipRiskLimits.klass = rb_define_class_under(mQuickfix, "NoRelationshipRiskLimits", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelationshipRiskLimits, (void *) &cNoRelationshipRiskLimits);
  rb_define_alloc_func(cNoRelationshipRiskLimits.klass, _wrap_NoRelationshipRiskLimits_allocate);
  rb_define_method(cNoRelationshipRiskLimits.klass, "initialize", VALUEFUNC(_wrap_new_NoRelationshipRiskLimits), -1);
  cNoRelationshipRiskLimits.mark = 0;
  cNoRelationshipRiskLimits.destroy = (void (*)(void *)) free_FIX_NoRelationshipRiskLimits;
  cNoRelationshipRiskLimits.trackObjects = 0;
  
  cLocationID.klass = rb_define_class_under(mQuickfix, "LocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LocationID, (void *) &cLocationID);
  rb_define_alloc_func(cLocationID.klass, _wrap_LocationID_allocate);
  rb_define_method(cLocationID.klass, "initialize", VALUEFUNC(_wrap_new_LocationID), -1);
  cLocationID.mark = 0;
  cLocationID.destroy = (void (*)(void *)) free_FIX_LocationID;
  cLocationID.trackObjects = 0;
  
  cCurrency.klass = rb_define_class_under(mQuickfix, "Currency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Currency, (void *) &cCurrency);
  rb_define_alloc_func(cCurrency.klass, _wrap_Currency_allocate);
  rb_define_method(cCurrency.klass, "initialize", VALUEFUNC(_wrap_new_Currency), -1);
  cCurrency.mark = 0;
  cCurrency.destroy = (void (*)(void *)) free_FIX_Currency;
  cCurrency.trackObjects = 0;
  
  cRoutingType.klass = rb_define_class_under(mQuickfix, "RoutingType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoutingType, (void *) &cRoutingType);
  rb_define_alloc_func(cRoutingType.klass, _wrap_RoutingType_allocate);
  rb_define_method(cRoutingType.klass, "initialize", VALUEFUNC(_wrap_new_RoutingType), -1);
  cRoutingType.mark = 0;
  cRoutingType.destroy = (void (*)(void *)) free_FIX_RoutingType;
  cRoutingType.trackObjects = 0;
  
  cUnderlyingStrikePrice.klass = rb_define_class_under(mQuickfix, "UnderlyingStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStrikePrice, (void *) &cUnderlyingStrikePrice);
  rb_define_alloc_func(cUnderlyingStrikePrice.klass, _wrap_UnderlyingStrikePrice_allocate);
  rb_define_method(cUnderlyingStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStrikePrice), -1);
  cUnderlyingStrikePrice.mark = 0;
  cUnderlyingStrikePrice.destroy = (void (*)(void *)) free_FIX_UnderlyingStrikePrice;
  cUnderlyingStrikePrice.trackObjects = 0;
  
  cBidTradeType.klass = rb_define_class_under(mQuickfix, "BidTradeType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidTradeType, (void *) &cBidTradeType);
  rb_define_alloc_func(cBidTradeType.klass, _wrap_BidTradeType_allocate);
  rb_define_method(cBidTradeType.klass, "initialize", VALUEFUNC(_wrap_new_BidTradeType), -1);
  cBidTradeType.mark = 0;
  cBidTradeType.destroy = (void (*)(void *)) free_FIX_BidTradeType;
  cBidTradeType.trackObjects = 0;
  
  cRelationshipRiskInstrumentOperator.klass = rb_define_class_under(mQuickfix, "RelationshipRiskInstrumentOperator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskInstrumentOperator, (void *) &cRelationshipRiskInstrumentOperator);
  rb_define_alloc_func(cRelationshipRiskInstrumentOperator.klass, _wrap_RelationshipRiskInstrumentOperator_allocate);
  rb_define_method(cRelationshipRiskInstrumentOperator.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskInstrumentOperator), -1);
  cRelationshipRiskInstrumentOperator.mark = 0;
  cRelationshipRiskInstrumentOperator.destroy = (void (*)(void *)) free_FIX_RelationshipRiskInstrumentOperator;
  cRelationshipRiskInstrumentOperator.trackObjects = 0;
  
  cUnderlyingAttachmentPoint.klass = rb_define_class_under(mQuickfix, "UnderlyingAttachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingAttachmentPoint, (void *) &cUnderlyingAttachmentPoint);
  rb_define_alloc_func(cUnderlyingAttachmentPoint.klass, _wrap_UnderlyingAttachmentPoint_allocate);
  rb_define_method(cUnderlyingAttachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingAttachmentPoint), -1);
  cUnderlyingAttachmentPoint.mark = 0;
  cUnderlyingAttachmentPoint.destroy = (void (*)(void *)) free_FIX_UnderlyingAttachmentPoint;
  cUnderlyingAttachmentPoint.trackObjects = 0;
  
  cTotNoRejQuotes.klass = rb_define_class_under(mQuickfix, "TotNoRejQuotes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoRejQuotes, (void *) &cTotNoRejQuotes);
  rb_define_alloc_func(cTotNoRejQuotes.klass, _wrap_TotNoRejQuotes_allocate);
  rb_define_method(cTotNoRejQuotes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoRejQuotes), -1);
  cTotNoRejQuotes.mark = 0;
  cTotNoRejQuotes.destroy = (void (*)(void *)) free_FIX_TotNoRejQuotes;
  cTotNoRejQuotes.trackObjects = 0;
  
  cOrdStatusReqID.klass = rb_define_class_under(mQuickfix, "OrdStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdStatusReqID, (void *) &cOrdStatusReqID);
  rb_define_alloc_func(cOrdStatusReqID.klass, _wrap_OrdStatusReqID_allocate);
  rb_define_method(cOrdStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_OrdStatusReqID), -1);
  cOrdStatusReqID.mark = 0;
  cOrdStatusReqID.destroy = (void (*)(void *)) free_FIX_OrdStatusReqID;
  cOrdStatusReqID.trackObjects = 0;
  
  cSenderCompID.klass = rb_define_class_under(mQuickfix, "SenderCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SenderCompID, (void *) &cSenderCompID);
  rb_define_alloc_func(cSenderCompID.klass, _wrap_SenderCompID_allocate);
  rb_define_method(cSenderCompID.klass, "initialize", VALUEFUNC(_wrap_new_SenderCompID), -1);
  cSenderCompID.mark = 0;
  cSenderCompID.destroy = (void (*)(void *)) free_FIX_SenderCompID;
  cSenderCompID.trackObjects = 0;
  
  cOrdRejReason.klass = rb_define_class_under(mQuickfix, "OrdRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdRejReason, (void *) &cOrdRejReason);
  rb_define_alloc_func(cOrdRejReason.klass, _wrap_OrdRejReason_allocate);
  rb_define_method(cOrdRejReason.klass, "initialize", VALUEFUNC(_wrap_new_OrdRejReason), -1);
  cOrdRejReason.mark = 0;
  cOrdRejReason.destroy = (void (*)(void *)) free_FIX_OrdRejReason;
  cOrdRejReason.trackObjects = 0;
  
  cMaturityMonthYearIncrementUnits.klass = rb_define_class_under(mQuickfix, "MaturityMonthYearIncrementUnits", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYearIncrementUnits, (void *) &cMaturityMonthYearIncrementUnits);
  rb_define_alloc_func(cMaturityMonthYearIncrementUnits.klass, _wrap_MaturityMonthYearIncrementUnits_allocate);
  rb_define_method(cMaturityMonthYearIncrementUnits.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYearIncrementUnits), -1);
  cMaturityMonthYearIncrementUnits.mark = 0;
  cMaturityMonthYearIncrementUnits.destroy = (void (*)(void *)) free_FIX_MaturityMonthYearIncrementUnits;
  cMaturityMonthYearIncrementUnits.trackObjects = 0;
  
  cDisplayWhen.klass = rb_define_class_under(mQuickfix, "DisplayWhen", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayWhen, (void *) &cDisplayWhen);
  rb_define_alloc_func(cDisplayWhen.klass, _wrap_DisplayWhen_allocate);
  rb_define_method(cDisplayWhen.klass, "initialize", VALUEFUNC(_wrap_new_DisplayWhen), -1);
  cDisplayWhen.mark = 0;
  cDisplayWhen.destroy = (void (*)(void *)) free_FIX_DisplayWhen;
  cDisplayWhen.trackObjects = 0;
  
  cApplQueueAction.klass = rb_define_class_under(mQuickfix, "ApplQueueAction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueAction, (void *) &cApplQueueAction);
  rb_define_alloc_func(cApplQueueAction.klass, _wrap_ApplQueueAction_allocate);
  rb_define_method(cApplQueueAction.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueAction), -1);
  cApplQueueAction.mark = 0;
  cApplQueueAction.destroy = (void (*)(void *)) free_FIX_ApplQueueAction;
  cApplQueueAction.trackObjects = 0;
  
  cRegistTransType.klass = rb_define_class_under(mQuickfix, "RegistTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistTransType, (void *) &cRegistTransType);
  rb_define_alloc_func(cRegistTransType.klass, _wrap_RegistTransType_allocate);
  rb_define_method(cRegistTransType.klass, "initialize", VALUEFUNC(_wrap_new_RegistTransType), -1);
  cRegistTransType.mark = 0;
  cRegistTransType.destroy = (void (*)(void *)) free_FIX_RegistTransType;
  cRegistTransType.trackObjects = 0;
  
  cPaymentRemitterID.klass = rb_define_class_under(mQuickfix, "PaymentRemitterID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentRemitterID, (void *) &cPaymentRemitterID);
  rb_define_alloc_func(cPaymentRemitterID.klass, _wrap_PaymentRemitterID_allocate);
  rb_define_method(cPaymentRemitterID.klass, "initialize", VALUEFUNC(_wrap_new_PaymentRemitterID), -1);
  cPaymentRemitterID.mark = 0;
  cPaymentRemitterID.destroy = (void (*)(void *)) free_FIX_PaymentRemitterID;
  cPaymentRemitterID.trackObjects = 0;
  
  cPriceType.klass = rb_define_class_under(mQuickfix, "PriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceType, (void *) &cPriceType);
  rb_define_alloc_func(cPriceType.klass, _wrap_PriceType_allocate);
  rb_define_method(cPriceType.klass, "initialize", VALUEFUNC(_wrap_new_PriceType), -1);
  cPriceType.mark = 0;
  cPriceType.destroy = (void (*)(void *)) free_FIX_PriceType;
  cPriceType.trackObjects = 0;
  
  cMarketReqID.klass = rb_define_class_under(mQuickfix, "MarketReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketReqID, (void *) &cMarketReqID);
  rb_define_alloc_func(cMarketReqID.klass, _wrap_MarketReqID_allocate);
  rb_define_method(cMarketReqID.klass, "initialize", VALUEFUNC(_wrap_new_MarketReqID), -1);
  cMarketReqID.mark = 0;
  cMarketReqID.destroy = (void (*)(void *)) free_FIX_MarketReqID;
  cMarketReqID.trackObjects = 0;
  
  cNoNestedInstrAttrib.klass = rb_define_class_under(mQuickfix, "NoNestedInstrAttrib", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNestedInstrAttrib, (void *) &cNoNestedInstrAttrib);
  rb_define_alloc_func(cNoNestedInstrAttrib.klass, _wrap_NoNestedInstrAttrib_allocate);
  rb_define_method(cNoNestedInstrAttrib.klass, "initialize", VALUEFUNC(_wrap_new_NoNestedInstrAttrib), -1);
  cNoNestedInstrAttrib.mark = 0;
  cNoNestedInstrAttrib.destroy = (void (*)(void *)) free_FIX_NoNestedInstrAttrib;
  cNoNestedInstrAttrib.trackObjects = 0;
  
  cSecuritySubType.klass = rb_define_class_under(mQuickfix, "SecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySubType, (void *) &cSecuritySubType);
  rb_define_alloc_func(cSecuritySubType.klass, _wrap_SecuritySubType_allocate);
  rb_define_method(cSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySubType), -1);
  cSecuritySubType.mark = 0;
  cSecuritySubType.destroy = (void (*)(void *)) free_FIX_SecuritySubType;
  cSecuritySubType.trackObjects = 0;
  
  cClOrdID.klass = rb_define_class_under(mQuickfix, "ClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClOrdID, (void *) &cClOrdID);
  rb_define_alloc_func(cClOrdID.klass, _wrap_ClOrdID_allocate);
  rb_define_method(cClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_ClOrdID), -1);
  cClOrdID.mark = 0;
  cClOrdID.destroy = (void (*)(void *)) free_FIX_ClOrdID;
  cClOrdID.trackObjects = 0;
  
  cMaturityDay.klass = rb_define_class_under(mQuickfix, "MaturityDay", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityDay, (void *) &cMaturityDay);
  rb_define_alloc_func(cMaturityDay.klass, _wrap_MaturityDay_allocate);
  rb_define_method(cMaturityDay.klass, "initialize", VALUEFUNC(_wrap_new_MaturityDay), -1);
  cMaturityDay.mark = 0;
  cMaturityDay.destroy = (void (*)(void *)) free_FIX_MaturityDay;
  cMaturityDay.trackObjects = 0;
  
  cUnderlyingSeniority.klass = rb_define_class_under(mQuickfix, "UnderlyingSeniority", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSeniority, (void *) &cUnderlyingSeniority);
  rb_define_alloc_func(cUnderlyingSeniority.klass, _wrap_UnderlyingSeniority_allocate);
  rb_define_method(cUnderlyingSeniority.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSeniority), -1);
  cUnderlyingSeniority.mark = 0;
  cUnderlyingSeniority.destroy = (void (*)(void *)) free_FIX_UnderlyingSeniority;
  cUnderlyingSeniority.trackObjects = 0;
  
  cMarketSegmentDesc.klass = rb_define_class_under(mQuickfix, "MarketSegmentDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketSegmentDesc, (void *) &cMarketSegmentDesc);
  rb_define_alloc_func(cMarketSegmentDesc.klass, _wrap_MarketSegmentDesc_allocate);
  rb_define_method(cMarketSegmentDesc.klass, "initialize", VALUEFUNC(_wrap_new_MarketSegmentDesc), -1);
  cMarketSegmentDesc.mark = 0;
  cMarketSegmentDesc.destroy = (void (*)(void *)) free_FIX_MarketSegmentDesc;
  cMarketSegmentDesc.trackObjects = 0;
  
  cNoMarketSegments.klass = rb_define_class_under(mQuickfix, "NoMarketSegments", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMarketSegments, (void *) &cNoMarketSegments);
  rb_define_alloc_func(cNoMarketSegments.klass, _wrap_NoMarketSegments_allocate);
  rb_define_method(cNoMarketSegments.klass, "initialize", VALUEFUNC(_wrap_new_NoMarketSegments), -1);
  cNoMarketSegments.mark = 0;
  cNoMarketSegments.destroy = (void (*)(void *)) free_FIX_NoMarketSegments;
  cNoMarketSegments.trackObjects = 0;
  
  cSettlObligMode.klass = rb_define_class_under(mQuickfix, "SettlObligMode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligMode, (void *) &cSettlObligMode);
  rb_define_alloc_func(cSettlObligMode.klass, _wrap_SettlObligMode_allocate);
  rb_define_method(cSettlObligMode.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligMode), -1);
  cSettlObligMode.mark = 0;
  cSettlObligMode.destroy = (void (*)(void *)) free_FIX_SettlObligMode;
  cSettlObligMode.trackObjects = 0;
  
  cSecurityUpdateAction.klass = rb_define_class_under(mQuickfix, "SecurityUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityUpdateAction, (void *) &cSecurityUpdateAction);
  rb_define_alloc_func(cSecurityUpdateAction.klass, _wrap_SecurityUpdateAction_allocate);
  rb_define_method(cSecurityUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_SecurityUpdateAction), -1);
  cSecurityUpdateAction.mark = 0;
  cSecurityUpdateAction.destroy = (void (*)(void *)) free_FIX_SecurityUpdateAction;
  cSecurityUpdateAction.trackObjects = 0;
  
  cNetworkRequestType.klass = rb_define_class_under(mQuickfix, "NetworkRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkRequestType, (void *) &cNetworkRequestType);
  rb_define_alloc_func(cNetworkRequestType.klass, _wrap_NetworkRequestType_allocate);
  rb_define_method(cNetworkRequestType.klass, "initialize", VALUEFUNC(_wrap_new_NetworkRequestType), -1);
  cNetworkRequestType.mark = 0;
  cNetworkRequestType.destroy = (void (*)(void *)) free_FIX_NetworkRequestType;
  cNetworkRequestType.trackObjects = 0;
  
  cLiquidityPctLow.klass = rb_define_class_under(mQuickfix, "LiquidityPctLow", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityPctLow, (void *) &cLiquidityPctLow);
  rb_define_alloc_func(cLiquidityPctLow.klass, _wrap_LiquidityPctLow_allocate);
  rb_define_method(cLiquidityPctLow.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityPctLow), -1);
  cLiquidityPctLow.mark = 0;
  cLiquidityPctLow.destroy = (void (*)(void *)) free_FIX_LiquidityPctLow;
  cLiquidityPctLow.trackObjects = 0;
  
  cPartyRole.klass = rb_define_class_under(mQuickfix, "PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyRole, (void *) &cPartyRole);
  rb_define_alloc_func(cPartyRole.klass, _wrap_PartyRole_allocate);
  rb_define_method(cPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_PartyRole), -1);
  cPartyRole.mark = 0;
  cPartyRole.destroy = (void (*)(void *)) free_FIX_PartyRole;
  cPartyRole.trackObjects = 0;
  
  cLegRatioQty.klass = rb_define_class_under(mQuickfix, "LegRatioQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRatioQty, (void *) &cLegRatioQty);
  rb_define_alloc_func(cLegRatioQty.klass, _wrap_LegRatioQty_allocate);
  rb_define_method(cLegRatioQty.klass, "initialize", VALUEFUNC(_wrap_new_LegRatioQty), -1);
  cLegRatioQty.mark = 0;
  cLegRatioQty.destroy = (void (*)(void *)) free_FIX_LegRatioQty;
  cLegRatioQty.trackObjects = 0;
  
  cSettlCurrFxRate.klass = rb_define_class_under(mQuickfix, "SettlCurrFxRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrFxRate, (void *) &cSettlCurrFxRate);
  rb_define_alloc_func(cSettlCurrFxRate.klass, _wrap_SettlCurrFxRate_allocate);
  rb_define_method(cSettlCurrFxRate.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrFxRate), -1);
  cSettlCurrFxRate.mark = 0;
  cSettlCurrFxRate.destroy = (void (*)(void *)) free_FIX_SettlCurrFxRate;
  cSettlCurrFxRate.trackObjects = 0;
  
  cRelatedPartyRole.klass = rb_define_class_under(mQuickfix, "RelatedPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartyRole, (void *) &cRelatedPartyRole);
  rb_define_alloc_func(cRelatedPartyRole.klass, _wrap_RelatedPartyRole_allocate);
  rb_define_method(cRelatedPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartyRole), -1);
  cRelatedPartyRole.mark = 0;
  cRelatedPartyRole.destroy = (void (*)(void *)) free_FIX_RelatedPartyRole;
  cRelatedPartyRole.trackObjects = 0;
  
  cLegContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "LegContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegContractMultiplierUnit, (void *) &cLegContractMultiplierUnit);
  rb_define_alloc_func(cLegContractMultiplierUnit.klass, _wrap_LegContractMultiplierUnit_allocate);
  rb_define_method(cLegContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_LegContractMultiplierUnit), -1);
  cLegContractMultiplierUnit.mark = 0;
  cLegContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_LegContractMultiplierUnit;
  cLegContractMultiplierUnit.trackObjects = 0;
  
  cSecureData.klass = rb_define_class_under(mQuickfix, "SecureData", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecureData, (void *) &cSecureData);
  rb_define_alloc_func(cSecureData.klass, _wrap_SecureData_allocate);
  rb_define_method(cSecureData.klass, "initialize", VALUEFUNC(_wrap_new_SecureData), -1);
  cSecureData.mark = 0;
  cSecureData.destroy = (void (*)(void *)) free_FIX_SecureData;
  cSecureData.trackObjects = 0;
  
  cSenderLocationID.klass = rb_define_class_under(mQuickfix, "SenderLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SenderLocationID, (void *) &cSenderLocationID);
  rb_define_alloc_func(cSenderLocationID.klass, _wrap_SenderLocationID_allocate);
  rb_define_method(cSenderLocationID.klass, "initialize", VALUEFUNC(_wrap_new_SenderLocationID), -1);
  cSenderLocationID.mark = 0;
  cSenderLocationID.destroy = (void (*)(void *)) free_FIX_SenderLocationID;
  cSenderLocationID.trackObjects = 0;
  
  cFirstPx.klass = rb_define_class_under(mQuickfix, "FirstPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FirstPx, (void *) &cFirstPx);
  rb_define_alloc_func(cFirstPx.klass, _wrap_FirstPx_allocate);
  rb_define_method(cFirstPx.klass, "initialize", VALUEFUNC(_wrap_new_FirstPx), -1);
  cFirstPx.mark = 0;
  cFirstPx.destroy = (void (*)(void *)) free_FIX_FirstPx;
  cFirstPx.trackObjects = 0;
  
  cEncodedLegIssuer.klass = rb_define_class_under(mQuickfix, "EncodedLegIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegIssuer, (void *) &cEncodedLegIssuer);
  rb_define_alloc_func(cEncodedLegIssuer.klass, _wrap_EncodedLegIssuer_allocate);
  rb_define_method(cEncodedLegIssuer.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegIssuer), -1);
  cEncodedLegIssuer.mark = 0;
  cEncodedLegIssuer.destroy = (void (*)(void *)) free_FIX_EncodedLegIssuer;
  cEncodedLegIssuer.trackObjects = 0;
  
  cAssignmentMethod.klass = rb_define_class_under(mQuickfix, "AssignmentMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AssignmentMethod, (void *) &cAssignmentMethod);
  rb_define_alloc_func(cAssignmentMethod.klass, _wrap_AssignmentMethod_allocate);
  rb_define_method(cAssignmentMethod.klass, "initialize", VALUEFUNC(_wrap_new_AssignmentMethod), -1);
  cAssignmentMethod.mark = 0;
  cAssignmentMethod.destroy = (void (*)(void *)) free_FIX_AssignmentMethod;
  cAssignmentMethod.trackObjects = 0;
  
  cRoutingID.klass = rb_define_class_under(mQuickfix, "RoutingID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoutingID, (void *) &cRoutingID);
  rb_define_alloc_func(cRoutingID.klass, _wrap_RoutingID_allocate);
  rb_define_method(cRoutingID.klass, "initialize", VALUEFUNC(_wrap_new_RoutingID), -1);
  cRoutingID.mark = 0;
  cRoutingID.destroy = (void (*)(void *)) free_FIX_RoutingID;
  cRoutingID.trackObjects = 0;
  
  cRelationshipRiskSecurityAltID.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityAltID, (void *) &cRelationshipRiskSecurityAltID);
  rb_define_alloc_func(cRelationshipRiskSecurityAltID.klass, _wrap_RelationshipRiskSecurityAltID_allocate);
  rb_define_method(cRelationshipRiskSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityAltID), -1);
  cRelationshipRiskSecurityAltID.mark = 0;
  cRelationshipRiskSecurityAltID.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityAltID;
  cRelationshipRiskSecurityAltID.trackObjects = 0;
  
  cRelatedPartyAltID.klass = rb_define_class_under(mQuickfix, "RelatedPartyAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartyAltID, (void *) &cRelatedPartyAltID);
  rb_define_alloc_func(cRelatedPartyAltID.klass, _wrap_RelatedPartyAltID_allocate);
  rb_define_method(cRelatedPartyAltID.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartyAltID), -1);
  cRelatedPartyAltID.mark = 0;
  cRelatedPartyAltID.destroy = (void (*)(void *)) free_FIX_RelatedPartyAltID;
  cRelatedPartyAltID.trackObjects = 0;
  
  cStrategyParameterType.klass = rb_define_class_under(mQuickfix, "StrategyParameterType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrategyParameterType, (void *) &cStrategyParameterType);
  rb_define_alloc_func(cStrategyParameterType.klass, _wrap_StrategyParameterType_allocate);
  rb_define_method(cStrategyParameterType.klass, "initialize", VALUEFUNC(_wrap_new_StrategyParameterType), -1);
  cStrategyParameterType.mark = 0;
  cStrategyParameterType.destroy = (void (*)(void *)) free_FIX_StrategyParameterType;
  cStrategyParameterType.trackObjects = 0;
  
  cEncryptMethod.klass = rb_define_class_under(mQuickfix, "EncryptMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptMethod, (void *) &cEncryptMethod);
  rb_define_alloc_func(cEncryptMethod.klass, _wrap_EncryptMethod_allocate);
  rb_define_method(cEncryptMethod.klass, "initialize", VALUEFUNC(_wrap_new_EncryptMethod), -1);
  cEncryptMethod.mark = 0;
  cEncryptMethod.destroy = (void (*)(void *)) free_FIX_EncryptMethod;
  cEncryptMethod.trackObjects = 0;
  
  cUnderlyingStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "UnderlyingStateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStateOrProvinceOfIssue, (void *) &cUnderlyingStateOrProvinceOfIssue);
  rb_define_alloc_func(cUnderlyingStateOrProvinceOfIssue.klass, _wrap_UnderlyingStateOrProvinceOfIssue_allocate);
  rb_define_method(cUnderlyingStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStateOrProvinceOfIssue), -1);
  cUnderlyingStateOrProvinceOfIssue.mark = 0;
  cUnderlyingStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_UnderlyingStateOrProvinceOfIssue;
  cUnderlyingStateOrProvinceOfIssue.trackObjects = 0;
  
  cApplNewSeqNum.klass = rb_define_class_under(mQuickfix, "ApplNewSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplNewSeqNum, (void *) &cApplNewSeqNum);
  rb_define_alloc_func(cApplNewSeqNum.klass, _wrap_ApplNewSeqNum_allocate);
  rb_define_method(cApplNewSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplNewSeqNum), -1);
  cApplNewSeqNum.mark = 0;
  cApplNewSeqNum.destroy = (void (*)(void *)) free_FIX_ApplNewSeqNum;
  cApplNewSeqNum.trackObjects = 0;
  
  cDerivativeEncodedSecurityDescLen.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedSecurityDescLen, (void *) &cDerivativeEncodedSecurityDescLen);
  rb_define_alloc_func(cDerivativeEncodedSecurityDescLen.klass, _wrap_DerivativeEncodedSecurityDescLen_allocate);
  rb_define_method(cDerivativeEncodedSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedSecurityDescLen), -1);
  cDerivativeEncodedSecurityDescLen.mark = 0;
  cDerivativeEncodedSecurityDescLen.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedSecurityDescLen;
  cDerivativeEncodedSecurityDescLen.trackObjects = 0;
  
  cTradingCurrency.klass = rb_define_class_under(mQuickfix, "TradingCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingCurrency, (void *) &cTradingCurrency);
  rb_define_alloc_func(cTradingCurrency.klass, _wrap_TradingCurrency_allocate);
  rb_define_method(cTradingCurrency.klass, "initialize", VALUEFUNC(_wrap_new_TradingCurrency), -1);
  cTradingCurrency.mark = 0;
  cTradingCurrency.destroy = (void (*)(void *)) free_FIX_TradingCurrency;
  cTradingCurrency.trackObjects = 0;
  
  cSecondaryHighLimitPrice.klass = rb_define_class_under(mQuickfix, "SecondaryHighLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryHighLimitPrice, (void *) &cSecondaryHighLimitPrice);
  rb_define_alloc_func(cSecondaryHighLimitPrice.klass, _wrap_SecondaryHighLimitPrice_allocate);
  rb_define_method(cSecondaryHighLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryHighLimitPrice), -1);
  cSecondaryHighLimitPrice.mark = 0;
  cSecondaryHighLimitPrice.destroy = (void (*)(void *)) free_FIX_SecondaryHighLimitPrice;
  cSecondaryHighLimitPrice.trackObjects = 0;
  
  cOrderAvgPx.klass = rb_define_class_under(mQuickfix, "OrderAvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderAvgPx, (void *) &cOrderAvgPx);
  rb_define_alloc_func(cOrderAvgPx.klass, _wrap_OrderAvgPx_allocate);
  rb_define_method(cOrderAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_OrderAvgPx), -1);
  cOrderAvgPx.mark = 0;
  cOrderAvgPx.destroy = (void (*)(void *)) free_FIX_OrderAvgPx;
  cOrderAvgPx.trackObjects = 0;
  
  cPosAmtType.klass = rb_define_class_under(mQuickfix, "PosAmtType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosAmtType, (void *) &cPosAmtType);
  rb_define_alloc_func(cPosAmtType.klass, _wrap_PosAmtType_allocate);
  rb_define_method(cPosAmtType.klass, "initialize", VALUEFUNC(_wrap_new_PosAmtType), -1);
  cPosAmtType.mark = 0;
  cPosAmtType.destroy = (void (*)(void *)) free_FIX_PosAmtType;
  cPosAmtType.trackObjects = 0;
  
  cResetSeqNumFlag.klass = rb_define_class_under(mQuickfix, "ResetSeqNumFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ResetSeqNumFlag, (void *) &cResetSeqNumFlag);
  rb_define_alloc_func(cResetSeqNumFlag.klass, _wrap_ResetSeqNumFlag_allocate);
  rb_define_method(cResetSeqNumFlag.klass, "initialize", VALUEFUNC(_wrap_new_ResetSeqNumFlag), -1);
  cResetSeqNumFlag.mark = 0;
  cResetSeqNumFlag.destroy = (void (*)(void *)) free_FIX_ResetSeqNumFlag;
  cResetSeqNumFlag.trackObjects = 0;
  
  cNoHops.klass = rb_define_class_under(mQuickfix, "NoHops", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoHops, (void *) &cNoHops);
  rb_define_alloc_func(cNoHops.klass, _wrap_NoHops_allocate);
  rb_define_method(cNoHops.klass, "initialize", VALUEFUNC(_wrap_new_NoHops), -1);
  cNoHops.mark = 0;
  cNoHops.destroy = (void (*)(void *)) free_FIX_NoHops;
  cNoHops.trackObjects = 0;
  
  cCollInquiryResult.klass = rb_define_class_under(mQuickfix, "CollInquiryResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryResult, (void *) &cCollInquiryResult);
  rb_define_alloc_func(cCollInquiryResult.klass, _wrap_CollInquiryResult_allocate);
  rb_define_method(cCollInquiryResult.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryResult), -1);
  cCollInquiryResult.mark = 0;
  cCollInquiryResult.destroy = (void (*)(void *)) free_FIX_CollInquiryResult;
  cCollInquiryResult.trackObjects = 0;
  
  cStartDate.klass = rb_define_class_under(mQuickfix, "StartDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartDate, (void *) &cStartDate);
  rb_define_alloc_func(cStartDate.klass, _wrap_StartDate_allocate);
  rb_define_method(cStartDate.klass, "initialize", VALUEFUNC(_wrap_new_StartDate), -1);
  cStartDate.mark = 0;
  cStartDate.destroy = (void (*)(void *)) free_FIX_StartDate;
  cStartDate.trackObjects = 0;
  
  cCollAsgnRespType.klass = rb_define_class_under(mQuickfix, "CollAsgnRespType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnRespType, (void *) &cCollAsgnRespType);
  rb_define_alloc_func(cCollAsgnRespType.klass, _wrap_CollAsgnRespType_allocate);
  rb_define_method(cCollAsgnRespType.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnRespType), -1);
  cCollAsgnRespType.mark = 0;
  cCollAsgnRespType.destroy = (void (*)(void *)) free_FIX_CollAsgnRespType;
  cCollAsgnRespType.trackObjects = 0;
  
  cOrderBookingQty.klass = rb_define_class_under(mQuickfix, "OrderBookingQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderBookingQty, (void *) &cOrderBookingQty);
  rb_define_alloc_func(cOrderBookingQty.klass, _wrap_OrderBookingQty_allocate);
  rb_define_method(cOrderBookingQty.klass, "initialize", VALUEFUNC(_wrap_new_OrderBookingQty), -1);
  cOrderBookingQty.mark = 0;
  cOrderBookingQty.destroy = (void (*)(void *)) free_FIX_OrderBookingQty;
  cOrderBookingQty.trackObjects = 0;
  
  cNoQuoteQualifiers.klass = rb_define_class_under(mQuickfix, "NoQuoteQualifiers", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoQuoteQualifiers, (void *) &cNoQuoteQualifiers);
  rb_define_alloc_func(cNoQuoteQualifiers.klass, _wrap_NoQuoteQualifiers_allocate);
  rb_define_method(cNoQuoteQualifiers.klass, "initialize", VALUEFUNC(_wrap_new_NoQuoteQualifiers), -1);
  cNoQuoteQualifiers.mark = 0;
  cNoQuoteQualifiers.destroy = (void (*)(void *)) free_FIX_NoQuoteQualifiers;
  cNoQuoteQualifiers.trackObjects = 0;
  
  cUnsolicitedIndicator.klass = rb_define_class_under(mQuickfix, "UnsolicitedIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnsolicitedIndicator, (void *) &cUnsolicitedIndicator);
  rb_define_alloc_func(cUnsolicitedIndicator.klass, _wrap_UnsolicitedIndicator_allocate);
  rb_define_method(cUnsolicitedIndicator.klass, "initialize", VALUEFUNC(_wrap_new_UnsolicitedIndicator), -1);
  cUnsolicitedIndicator.mark = 0;
  cUnsolicitedIndicator.destroy = (void (*)(void *)) free_FIX_UnsolicitedIndicator;
  cUnsolicitedIndicator.trackObjects = 0;
  
  cRefCstmApplVerID.klass = rb_define_class_under(mQuickfix, "RefCstmApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefCstmApplVerID, (void *) &cRefCstmApplVerID);
  rb_define_alloc_func(cRefCstmApplVerID.klass, _wrap_RefCstmApplVerID_allocate);
  rb_define_method(cRefCstmApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_RefCstmApplVerID), -1);
  cRefCstmApplVerID.mark = 0;
  cRefCstmApplVerID.destroy = (void (*)(void *)) free_FIX_RefCstmApplVerID;
  cRefCstmApplVerID.trackObjects = 0;
  
  cSideExecID.klass = rb_define_class_under(mQuickfix, "SideExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideExecID, (void *) &cSideExecID);
  rb_define_alloc_func(cSideExecID.klass, _wrap_SideExecID_allocate);
  rb_define_method(cSideExecID.klass, "initialize", VALUEFUNC(_wrap_new_SideExecID), -1);
  cSideExecID.mark = 0;
  cSideExecID.destroy = (void (*)(void *)) free_FIX_SideExecID;
  cSideExecID.trackObjects = 0;
  
  cRejectText.klass = rb_define_class_under(mQuickfix, "RejectText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RejectText, (void *) &cRejectText);
  rb_define_alloc_func(cRejectText.klass, _wrap_RejectText_allocate);
  rb_define_method(cRejectText.klass, "initialize", VALUEFUNC(_wrap_new_RejectText), -1);
  cRejectText.mark = 0;
  cRejectText.destroy = (void (*)(void *)) free_FIX_RejectText;
  cRejectText.trackObjects = 0;
  
  cExchangeSpecialInstructions.klass = rb_define_class_under(mQuickfix, "ExchangeSpecialInstructions", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExchangeSpecialInstructions, (void *) &cExchangeSpecialInstructions);
  rb_define_alloc_func(cExchangeSpecialInstructions.klass, _wrap_ExchangeSpecialInstructions_allocate);
  rb_define_method(cExchangeSpecialInstructions.klass, "initialize", VALUEFUNC(_wrap_new_ExchangeSpecialInstructions), -1);
  cExchangeSpecialInstructions.mark = 0;
  cExchangeSpecialInstructions.destroy = (void (*)(void *)) free_FIX_ExchangeSpecialInstructions;
  cExchangeSpecialInstructions.trackObjects = 0;
  
  cTradeID.klass = rb_define_class_under(mQuickfix, "TradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeID, (void *) &cTradeID);
  rb_define_alloc_func(cTradeID.klass, _wrap_TradeID_allocate);
  rb_define_method(cTradeID.klass, "initialize", VALUEFUNC(_wrap_new_TradeID), -1);
  cTradeID.mark = 0;
  cTradeID.destroy = (void (*)(void *)) free_FIX_TradeID;
  cTradeID.trackObjects = 0;
  
  cRndPx.klass = rb_define_class_under(mQuickfix, "RndPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RndPx, (void *) &cRndPx);
  rb_define_alloc_func(cRndPx.klass, _wrap_RndPx_allocate);
  rb_define_method(cRndPx.klass, "initialize", VALUEFUNC(_wrap_new_RndPx), -1);
  cRndPx.mark = 0;
  cRndPx.destroy = (void (*)(void *)) free_FIX_RndPx;
  cRndPx.trackObjects = 0;
  
  cQuoteEntryRejectReason.klass = rb_define_class_under(mQuickfix, "QuoteEntryRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteEntryRejectReason, (void *) &cQuoteEntryRejectReason);
  rb_define_alloc_func(cQuoteEntryRejectReason.klass, _wrap_QuoteEntryRejectReason_allocate);
  rb_define_method(cQuoteEntryRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_QuoteEntryRejectReason), -1);
  cQuoteEntryRejectReason.mark = 0;
  cQuoteEntryRejectReason.destroy = (void (*)(void *)) free_FIX_QuoteEntryRejectReason;
  cQuoteEntryRejectReason.trackObjects = 0;
  
  cOrderCapacity.klass = rb_define_class_under(mQuickfix, "OrderCapacity", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderCapacity, (void *) &cOrderCapacity);
  rb_define_alloc_func(cOrderCapacity.klass, _wrap_OrderCapacity_allocate);
  rb_define_method(cOrderCapacity.klass, "initialize", VALUEFUNC(_wrap_new_OrderCapacity), -1);
  cOrderCapacity.mark = 0;
  cOrderCapacity.destroy = (void (*)(void *)) free_FIX_OrderCapacity;
  cOrderCapacity.trackObjects = 0;
  
  cSideLastQty.klass = rb_define_class_under(mQuickfix, "SideLastQty", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideLastQty, (void *) &cSideLastQty);
  rb_define_alloc_func(cSideLastQty.klass, _wrap_SideLastQty_allocate);
  rb_define_method(cSideLastQty.klass, "initialize", VALUEFUNC(_wrap_new_SideLastQty), -1);
  cSideLastQty.mark = 0;
  cSideLastQty.destroy = (void (*)(void *)) free_FIX_SideLastQty;
  cSideLastQty.trackObjects = 0;
  
  cDerivativeUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "DerivativeUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeUnitOfMeasure, (void *) &cDerivativeUnitOfMeasure);
  rb_define_alloc_func(cDerivativeUnitOfMeasure.klass, _wrap_DerivativeUnitOfMeasure_allocate);
  rb_define_method(cDerivativeUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeUnitOfMeasure), -1);
  cDerivativeUnitOfMeasure.mark = 0;
  cDerivativeUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_DerivativeUnitOfMeasure;
  cDerivativeUnitOfMeasure.trackObjects = 0;
  
  cNoLegAllocs.klass = rb_define_class_under(mQuickfix, "NoLegAllocs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegAllocs, (void *) &cNoLegAllocs);
  rb_define_alloc_func(cNoLegAllocs.klass, _wrap_NoLegAllocs_allocate);
  rb_define_method(cNoLegAllocs.klass, "initialize", VALUEFUNC(_wrap_new_NoLegAllocs), -1);
  cNoLegAllocs.mark = 0;
  cNoLegAllocs.destroy = (void (*)(void *)) free_FIX_NoLegAllocs;
  cNoLegAllocs.trackObjects = 0;
  
  cQuoteAckStatus.klass = rb_define_class_under(mQuickfix, "QuoteAckStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteAckStatus, (void *) &cQuoteAckStatus);
  rb_define_alloc_func(cQuoteAckStatus.klass, _wrap_QuoteAckStatus_allocate);
  rb_define_method(cQuoteAckStatus.klass, "initialize", VALUEFUNC(_wrap_new_QuoteAckStatus), -1);
  cQuoteAckStatus.mark = 0;
  cQuoteAckStatus.destroy = (void (*)(void *)) free_FIX_QuoteAckStatus;
  cQuoteAckStatus.trackObjects = 0;
  
  cSecondaryFirmTradeID.klass = rb_define_class_under(mQuickfix, "SecondaryFirmTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryFirmTradeID, (void *) &cSecondaryFirmTradeID);
  rb_define_alloc_func(cSecondaryFirmTradeID.klass, _wrap_SecondaryFirmTradeID_allocate);
  rb_define_method(cSecondaryFirmTradeID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryFirmTradeID), -1);
  cSecondaryFirmTradeID.mark = 0;
  cSecondaryFirmTradeID.destroy = (void (*)(void *)) free_FIX_SecondaryFirmTradeID;
  cSecondaryFirmTradeID.trackObjects = 0;
  
  cUserRequestType.klass = rb_define_class_under(mQuickfix, "UserRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserRequestType, (void *) &cUserRequestType);
  rb_define_alloc_func(cUserRequestType.klass, _wrap_UserRequestType_allocate);
  rb_define_method(cUserRequestType.klass, "initialize", VALUEFUNC(_wrap_new_UserRequestType), -1);
  cUserRequestType.mark = 0;
  cUserRequestType.destroy = (void (*)(void *)) free_FIX_UserRequestType;
  cUserRequestType.trackObjects = 0;
  
  cSecondaryTrdType.klass = rb_define_class_under(mQuickfix, "SecondaryTrdType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTrdType, (void *) &cSecondaryTrdType);
  rb_define_alloc_func(cSecondaryTrdType.klass, _wrap_SecondaryTrdType_allocate);
  rb_define_method(cSecondaryTrdType.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTrdType), -1);
  cSecondaryTrdType.mark = 0;
  cSecondaryTrdType.destroy = (void (*)(void *)) free_FIX_SecondaryTrdType;
  cSecondaryTrdType.trackObjects = 0;
  
  cTradeReportTransType.klass = rb_define_class_under(mQuickfix, "TradeReportTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportTransType, (void *) &cTradeReportTransType);
  rb_define_alloc_func(cTradeReportTransType.klass, _wrap_TradeReportTransType_allocate);
  rb_define_method(cTradeReportTransType.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportTransType), -1);
  cTradeReportTransType.mark = 0;
  cTradeReportTransType.destroy = (void (*)(void *)) free_FIX_TradeReportTransType;
  cTradeReportTransType.trackObjects = 0;
  
  cAdvSide.klass = rb_define_class_under(mQuickfix, "AdvSide", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvSide, (void *) &cAdvSide);
  rb_define_alloc_func(cAdvSide.klass, _wrap_AdvSide_allocate);
  rb_define_method(cAdvSide.klass, "initialize", VALUEFUNC(_wrap_new_AdvSide), -1);
  cAdvSide.mark = 0;
  cAdvSide.destroy = (void (*)(void *)) free_FIX_AdvSide;
  cAdvSide.trackObjects = 0;
  
  cRelatedContextPartySubID.klass = rb_define_class_under(mQuickfix, "RelatedContextPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedContextPartySubID, (void *) &cRelatedContextPartySubID);
  rb_define_alloc_func(cRelatedContextPartySubID.klass, _wrap_RelatedContextPartySubID_allocate);
  rb_define_method(cRelatedContextPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_RelatedContextPartySubID), -1);
  cRelatedContextPartySubID.mark = 0;
  cRelatedContextPartySubID.destroy = (void (*)(void *)) free_FIX_RelatedContextPartySubID;
  cRelatedContextPartySubID.trackObjects = 0;
  
  cDerivativeSecuritySubType.klass = rb_define_class_under(mQuickfix, "DerivativeSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecuritySubType, (void *) &cDerivativeSecuritySubType);
  rb_define_alloc_func(cDerivativeSecuritySubType.klass, _wrap_DerivativeSecuritySubType_allocate);
  rb_define_method(cDerivativeSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecuritySubType), -1);
  cDerivativeSecuritySubType.mark = 0;
  cDerivativeSecuritySubType.destroy = (void (*)(void *)) free_FIX_DerivativeSecuritySubType;
  cDerivativeSecuritySubType.trackObjects = 0;
  
  cTriggerTradingSessionSubID.klass = rb_define_class_under(mQuickfix, "TriggerTradingSessionSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerTradingSessionSubID, (void *) &cTriggerTradingSessionSubID);
  rb_define_alloc_func(cTriggerTradingSessionSubID.klass, _wrap_TriggerTradingSessionSubID_allocate);
  rb_define_method(cTriggerTradingSessionSubID.klass, "initialize", VALUEFUNC(_wrap_new_TriggerTradingSessionSubID), -1);
  cTriggerTradingSessionSubID.mark = 0;
  cTriggerTradingSessionSubID.destroy = (void (*)(void *)) free_FIX_TriggerTradingSessionSubID;
  cTriggerTradingSessionSubID.trackObjects = 0;
  
  cTradeLinkID.klass = rb_define_class_under(mQuickfix, "TradeLinkID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeLinkID, (void *) &cTradeLinkID);
  rb_define_alloc_func(cTradeLinkID.klass, _wrap_TradeLinkID_allocate);
  rb_define_method(cTradeLinkID.klass, "initialize", VALUEFUNC(_wrap_new_TradeLinkID), -1);
  cTradeLinkID.mark = 0;
  cTradeLinkID.destroy = (void (*)(void *)) free_FIX_TradeLinkID;
  cTradeLinkID.trackObjects = 0;
  
  cLegBenchmarkPrice.klass = rb_define_class_under(mQuickfix, "LegBenchmarkPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkPrice, (void *) &cLegBenchmarkPrice);
  rb_define_alloc_func(cLegBenchmarkPrice.klass, _wrap_LegBenchmarkPrice_allocate);
  rb_define_method(cLegBenchmarkPrice.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkPrice), -1);
  cLegBenchmarkPrice.mark = 0;
  cLegBenchmarkPrice.destroy = (void (*)(void *)) free_FIX_LegBenchmarkPrice;
  cLegBenchmarkPrice.trackObjects = 0;
  
  cHopRefID.klass = rb_define_class_under(mQuickfix, "HopRefID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HopRefID, (void *) &cHopRefID);
  rb_define_alloc_func(cHopRefID.klass, _wrap_HopRefID_allocate);
  rb_define_method(cHopRefID.klass, "initialize", VALUEFUNC(_wrap_new_HopRefID), -1);
  cHopRefID.mark = 0;
  cHopRefID.destroy = (void (*)(void *)) free_FIX_HopRefID;
  cHopRefID.trackObjects = 0;
  
  cDesignation.klass = rb_define_class_under(mQuickfix, "Designation", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Designation, (void *) &cDesignation);
  rb_define_alloc_func(cDesignation.klass, _wrap_Designation_allocate);
  rb_define_method(cDesignation.klass, "initialize", VALUEFUNC(_wrap_new_Designation), -1);
  cDesignation.mark = 0;
  cDesignation.destroy = (void (*)(void *)) free_FIX_Designation;
  cDesignation.trackObjects = 0;
  
  cTradeRequestID.klass = rb_define_class_under(mQuickfix, "TradeRequestID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestID, (void *) &cTradeRequestID);
  rb_define_alloc_func(cTradeRequestID.klass, _wrap_TradeRequestID_allocate);
  rb_define_method(cTradeRequestID.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestID), -1);
  cTradeRequestID.mark = 0;
  cTradeRequestID.destroy = (void (*)(void *)) free_FIX_TradeRequestID;
  cTradeRequestID.trackObjects = 0;
  
  cRelationshipRiskLimitType.klass = rb_define_class_under(mQuickfix, "RelationshipRiskLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskLimitType, (void *) &cRelationshipRiskLimitType);
  rb_define_alloc_func(cRelationshipRiskLimitType.klass, _wrap_RelationshipRiskLimitType_allocate);
  rb_define_method(cRelationshipRiskLimitType.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskLimitType), -1);
  cRelationshipRiskLimitType.mark = 0;
  cRelationshipRiskLimitType.destroy = (void (*)(void *)) free_FIX_RelationshipRiskLimitType;
  cRelationshipRiskLimitType.trackObjects = 0;
  
  cRiskSecurityIDSource.klass = rb_define_class_under(mQuickfix, "RiskSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityIDSource, (void *) &cRiskSecurityIDSource);
  rb_define_alloc_func(cRiskSecurityIDSource.klass, _wrap_RiskSecurityIDSource_allocate);
  rb_define_method(cRiskSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityIDSource), -1);
  cRiskSecurityIDSource.mark = 0;
  cRiskSecurityIDSource.destroy = (void (*)(void *)) free_FIX_RiskSecurityIDSource;
  cRiskSecurityIDSource.trackObjects = 0;
  
  cLegFlowScheduleType.klass = rb_define_class_under(mQuickfix, "LegFlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegFlowScheduleType, (void *) &cLegFlowScheduleType);
  rb_define_alloc_func(cLegFlowScheduleType.klass, _wrap_LegFlowScheduleType_allocate);
  rb_define_method(cLegFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_LegFlowScheduleType), -1);
  cLegFlowScheduleType.mark = 0;
  cLegFlowScheduleType.destroy = (void (*)(void *)) free_FIX_LegFlowScheduleType;
  cLegFlowScheduleType.trackObjects = 0;
  
  cLegPriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "LegPriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPriceUnitOfMeasure, (void *) &cLegPriceUnitOfMeasure);
  rb_define_alloc_func(cLegPriceUnitOfMeasure.klass, _wrap_LegPriceUnitOfMeasure_allocate);
  rb_define_method(cLegPriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_LegPriceUnitOfMeasure), -1);
  cLegPriceUnitOfMeasure.mark = 0;
  cLegPriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_LegPriceUnitOfMeasure;
  cLegPriceUnitOfMeasure.trackObjects = 0;
  
  cNested4PartyIDSource.klass = rb_define_class_under(mQuickfix, "Nested4PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartyIDSource, (void *) &cNested4PartyIDSource);
  rb_define_alloc_func(cNested4PartyIDSource.klass, _wrap_Nested4PartyIDSource_allocate);
  rb_define_method(cNested4PartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartyIDSource), -1);
  cNested4PartyIDSource.mark = 0;
  cNested4PartyIDSource.destroy = (void (*)(void *)) free_FIX_Nested4PartyIDSource;
  cNested4PartyIDSource.trackObjects = 0;
  
  cCoveredOrUncovered.klass = rb_define_class_under(mQuickfix, "CoveredOrUncovered", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CoveredOrUncovered, (void *) &cCoveredOrUncovered);
  rb_define_alloc_func(cCoveredOrUncovered.klass, _wrap_CoveredOrUncovered_allocate);
  rb_define_method(cCoveredOrUncovered.klass, "initialize", VALUEFUNC(_wrap_new_CoveredOrUncovered), -1);
  cCoveredOrUncovered.mark = 0;
  cCoveredOrUncovered.destroy = (void (*)(void *)) free_FIX_CoveredOrUncovered;
  cCoveredOrUncovered.trackObjects = 0;
  
  cAcctIDSource.klass = rb_define_class_under(mQuickfix, "AcctIDSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AcctIDSource, (void *) &cAcctIDSource);
  rb_define_alloc_func(cAcctIDSource.klass, _wrap_AcctIDSource_allocate);
  rb_define_method(cAcctIDSource.klass, "initialize", VALUEFUNC(_wrap_new_AcctIDSource), -1);
  cAcctIDSource.mark = 0;
  cAcctIDSource.destroy = (void (*)(void *)) free_FIX_AcctIDSource;
  cAcctIDSource.trackObjects = 0;
  
  cMktOfferPx.klass = rb_define_class_under(mQuickfix, "MktOfferPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MktOfferPx, (void *) &cMktOfferPx);
  rb_define_alloc_func(cMktOfferPx.klass, _wrap_MktOfferPx_allocate);
  rb_define_method(cMktOfferPx.klass, "initialize", VALUEFUNC(_wrap_new_MktOfferPx), -1);
  cMktOfferPx.mark = 0;
  cMktOfferPx.destroy = (void (*)(void *)) free_FIX_MktOfferPx;
  cMktOfferPx.trackObjects = 0;
  
  cNoCapacities.klass = rb_define_class_under(mQuickfix, "NoCapacities", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoCapacities, (void *) &cNoCapacities);
  rb_define_alloc_func(cNoCapacities.klass, _wrap_NoCapacities_allocate);
  rb_define_method(cNoCapacities.klass, "initialize", VALUEFUNC(_wrap_new_NoCapacities), -1);
  cNoCapacities.mark = 0;
  cNoCapacities.destroy = (void (*)(void *)) free_FIX_NoCapacities;
  cNoCapacities.trackObjects = 0;
  
  cTradeRequestType.klass = rb_define_class_under(mQuickfix, "TradeRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestType, (void *) &cTradeRequestType);
  rb_define_alloc_func(cTradeRequestType.klass, _wrap_TradeRequestType_allocate);
  rb_define_method(cTradeRequestType.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestType), -1);
  cTradeRequestType.mark = 0;
  cTradeRequestType.destroy = (void (*)(void *)) free_FIX_TradeRequestType;
  cTradeRequestType.trackObjects = 0;
  
  cNoNestedPartyIDs.klass = rb_define_class_under(mQuickfix, "NoNestedPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNestedPartyIDs, (void *) &cNoNestedPartyIDs);
  rb_define_alloc_func(cNoNestedPartyIDs.klass, _wrap_NoNestedPartyIDs_allocate);
  rb_define_method(cNoNestedPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNestedPartyIDs), -1);
  cNoNestedPartyIDs.mark = 0;
  cNoNestedPartyIDs.destroy = (void (*)(void *)) free_FIX_NoNestedPartyIDs;
  cNoNestedPartyIDs.trackObjects = 0;
  
  cTradSesStatus.klass = rb_define_class_under(mQuickfix, "TradSesStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesStatus, (void *) &cTradSesStatus);
  rb_define_alloc_func(cTradSesStatus.klass, _wrap_TradSesStatus_allocate);
  rb_define_method(cTradSesStatus.klass, "initialize", VALUEFUNC(_wrap_new_TradSesStatus), -1);
  cTradSesStatus.mark = 0;
  cTradSesStatus.destroy = (void (*)(void *)) free_FIX_TradSesStatus;
  cTradSesStatus.trackObjects = 0;
  
  cUnderlyingNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "UnderlyingNotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingNotionalPercentageOutstanding, (void *) &cUnderlyingNotionalPercentageOutstanding);
  rb_define_alloc_func(cUnderlyingNotionalPercentageOutstanding.klass, _wrap_UnderlyingNotionalPercentageOutstanding_allocate);
  rb_define_method(cUnderlyingNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingNotionalPercentageOutstanding), -1);
  cUnderlyingNotionalPercentageOutstanding.mark = 0;
  cUnderlyingNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_UnderlyingNotionalPercentageOutstanding;
  cUnderlyingNotionalPercentageOutstanding.trackObjects = 0;
  
  cApplLastSeqNum.klass = rb_define_class_under(mQuickfix, "ApplLastSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplLastSeqNum, (void *) &cApplLastSeqNum);
  rb_define_alloc_func(cApplLastSeqNum.klass, _wrap_ApplLastSeqNum_allocate);
  rb_define_method(cApplLastSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplLastSeqNum), -1);
  cApplLastSeqNum.mark = 0;
  cApplLastSeqNum.destroy = (void (*)(void *)) free_FIX_ApplLastSeqNum;
  cApplLastSeqNum.trackObjects = 0;
  
  cPegPriceType.klass = rb_define_class_under(mQuickfix, "PegPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegPriceType, (void *) &cPegPriceType);
  rb_define_alloc_func(cPegPriceType.klass, _wrap_PegPriceType_allocate);
  rb_define_method(cPegPriceType.klass, "initialize", VALUEFUNC(_wrap_new_PegPriceType), -1);
  cPegPriceType.mark = 0;
  cPegPriceType.destroy = (void (*)(void *)) free_FIX_PegPriceType;
  cPegPriceType.trackObjects = 0;
  
  cStrategyParameterName.klass = rb_define_class_under(mQuickfix, "StrategyParameterName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrategyParameterName, (void *) &cStrategyParameterName);
  rb_define_alloc_func(cStrategyParameterName.klass, _wrap_StrategyParameterName_allocate);
  rb_define_method(cStrategyParameterName.klass, "initialize", VALUEFUNC(_wrap_new_StrategyParameterName), -1);
  cStrategyParameterName.mark = 0;
  cStrategyParameterName.destroy = (void (*)(void *)) free_FIX_StrategyParameterName;
  cStrategyParameterName.trackObjects = 0;
  
  cStreamAsgnRejReason.klass = rb_define_class_under(mQuickfix, "StreamAsgnRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnRejReason, (void *) &cStreamAsgnRejReason);
  rb_define_alloc_func(cStreamAsgnRejReason.klass, _wrap_StreamAsgnRejReason_allocate);
  rb_define_method(cStreamAsgnRejReason.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnRejReason), -1);
  cStreamAsgnRejReason.mark = 0;
  cStreamAsgnRejReason.destroy = (void (*)(void *)) free_FIX_StreamAsgnRejReason;
  cStreamAsgnRejReason.trackObjects = 0;
  
  cMatchIncrement.klass = rb_define_class_under(mQuickfix, "MatchIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchIncrement, (void *) &cMatchIncrement);
  rb_define_alloc_func(cMatchIncrement.klass, _wrap_MatchIncrement_allocate);
  rb_define_method(cMatchIncrement.klass, "initialize", VALUEFUNC(_wrap_new_MatchIncrement), -1);
  cMatchIncrement.mark = 0;
  cMatchIncrement.destroy = (void (*)(void *)) free_FIX_MatchIncrement;
  cMatchIncrement.trackObjects = 0;
  
  cNested3PartyRole.klass = rb_define_class_under(mQuickfix, "Nested3PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartyRole, (void *) &cNested3PartyRole);
  rb_define_alloc_func(cNested3PartyRole.klass, _wrap_Nested3PartyRole_allocate);
  rb_define_method(cNested3PartyRole.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartyRole), -1);
  cNested3PartyRole.mark = 0;
  cNested3PartyRole.destroy = (void (*)(void *)) free_FIX_Nested3PartyRole;
  cNested3PartyRole.trackObjects = 0;
  
  cUnderlyingPx.klass = rb_define_class_under(mQuickfix, "UnderlyingPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPx, (void *) &cUnderlyingPx);
  rb_define_alloc_func(cUnderlyingPx.klass, _wrap_UnderlyingPx_allocate);
  rb_define_method(cUnderlyingPx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPx), -1);
  cUnderlyingPx.mark = 0;
  cUnderlyingPx.destroy = (void (*)(void *)) free_FIX_UnderlyingPx;
  cUnderlyingPx.trackObjects = 0;
  
  cPriceImprovement.klass = rb_define_class_under(mQuickfix, "PriceImprovement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceImprovement, (void *) &cPriceImprovement);
  rb_define_alloc_func(cPriceImprovement.klass, _wrap_PriceImprovement_allocate);
  rb_define_method(cPriceImprovement.klass, "initialize", VALUEFUNC(_wrap_new_PriceImprovement), -1);
  cPriceImprovement.mark = 0;
  cPriceImprovement.destroy = (void (*)(void *)) free_FIX_PriceImprovement;
  cPriceImprovement.trackObjects = 0;
  
  cValuationMethod.klass = rb_define_class_under(mQuickfix, "ValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ValuationMethod, (void *) &cValuationMethod);
  rb_define_alloc_func(cValuationMethod.klass, _wrap_ValuationMethod_allocate);
  rb_define_method(cValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_ValuationMethod), -1);
  cValuationMethod.mark = 0;
  cValuationMethod.destroy = (void (*)(void *)) free_FIX_ValuationMethod;
  cValuationMethod.trackObjects = 0;
  
  cDerivativeSecurityID.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityID, (void *) &cDerivativeSecurityID);
  rb_define_alloc_func(cDerivativeSecurityID.klass, _wrap_DerivativeSecurityID_allocate);
  rb_define_method(cDerivativeSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityID), -1);
  cDerivativeSecurityID.mark = 0;
  cDerivativeSecurityID.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityID;
  cDerivativeSecurityID.trackObjects = 0;
  
  cNoExpiration.klass = rb_define_class_under(mQuickfix, "NoExpiration", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoExpiration, (void *) &cNoExpiration);
  rb_define_alloc_func(cNoExpiration.klass, _wrap_NoExpiration_allocate);
  rb_define_method(cNoExpiration.klass, "initialize", VALUEFUNC(_wrap_new_NoExpiration), -1);
  cNoExpiration.mark = 0;
  cNoExpiration.destroy = (void (*)(void *)) free_FIX_NoExpiration;
  cNoExpiration.trackObjects = 0;
  
  cTargetCompID.klass = rb_define_class_under(mQuickfix, "TargetCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetCompID, (void *) &cTargetCompID);
  rb_define_alloc_func(cTargetCompID.klass, _wrap_TargetCompID_allocate);
  rb_define_method(cTargetCompID.klass, "initialize", VALUEFUNC(_wrap_new_TargetCompID), -1);
  cTargetCompID.mark = 0;
  cTargetCompID.destroy = (void (*)(void *)) free_FIX_TargetCompID;
  cTargetCompID.trackObjects = 0;
  
  cMDEntryBuyer.klass = rb_define_class_under(mQuickfix, "MDEntryBuyer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryBuyer, (void *) &cMDEntryBuyer);
  rb_define_alloc_func(cMDEntryBuyer.klass, _wrap_MDEntryBuyer_allocate);
  rb_define_method(cMDEntryBuyer.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryBuyer), -1);
  cMDEntryBuyer.mark = 0;
  cMDEntryBuyer.destroy = (void (*)(void *)) free_FIX_MDEntryBuyer;
  cMDEntryBuyer.trackObjects = 0;
  
  cRelationshipRiskCouponRate.klass = rb_define_class_under(mQuickfix, "RelationshipRiskCouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskCouponRate, (void *) &cRelationshipRiskCouponRate);
  rb_define_alloc_func(cRelationshipRiskCouponRate.klass, _wrap_RelationshipRiskCouponRate_allocate);
  rb_define_method(cRelationshipRiskCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskCouponRate), -1);
  cRelationshipRiskCouponRate.mark = 0;
  cRelationshipRiskCouponRate.destroy = (void (*)(void *)) free_FIX_RelationshipRiskCouponRate;
  cRelationshipRiskCouponRate.trackObjects = 0;
  
  cNoDerivativeInstrumentPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoDerivativeInstrumentPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeInstrumentPartySubIDs, (void *) &cNoDerivativeInstrumentPartySubIDs);
  rb_define_alloc_func(cNoDerivativeInstrumentPartySubIDs.klass, _wrap_NoDerivativeInstrumentPartySubIDs_allocate);
  rb_define_method(cNoDerivativeInstrumentPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeInstrumentPartySubIDs), -1);
  cNoDerivativeInstrumentPartySubIDs.mark = 0;
  cNoDerivativeInstrumentPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoDerivativeInstrumentPartySubIDs;
  cNoDerivativeInstrumentPartySubIDs.trackObjects = 0;
  
  cNoMaturityRules.klass = rb_define_class_under(mQuickfix, "NoMaturityRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMaturityRules, (void *) &cNoMaturityRules);
  rb_define_alloc_func(cNoMaturityRules.klass, _wrap_NoMaturityRules_allocate);
  rb_define_method(cNoMaturityRules.klass, "initialize", VALUEFUNC(_wrap_new_NoMaturityRules), -1);
  cNoMaturityRules.mark = 0;
  cNoMaturityRules.destroy = (void (*)(void *)) free_FIX_NoMaturityRules;
  cNoMaturityRules.trackObjects = 0;
  
  cQuoteMsgID.klass = rb_define_class_under(mQuickfix, "QuoteMsgID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteMsgID, (void *) &cQuoteMsgID);
  rb_define_alloc_func(cQuoteMsgID.klass, _wrap_QuoteMsgID_allocate);
  rb_define_method(cQuoteMsgID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteMsgID), -1);
  cQuoteMsgID.mark = 0;
  cQuoteMsgID.destroy = (void (*)(void *)) free_FIX_QuoteMsgID;
  cQuoteMsgID.trackObjects = 0;
  
  cTriggerType.klass = rb_define_class_under(mQuickfix, "TriggerType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerType, (void *) &cTriggerType);
  rb_define_alloc_func(cTriggerType.klass, _wrap_TriggerType_allocate);
  rb_define_method(cTriggerType.klass, "initialize", VALUEFUNC(_wrap_new_TriggerType), -1);
  cTriggerType.mark = 0;
  cTriggerType.destroy = (void (*)(void *)) free_FIX_TriggerType;
  cTriggerType.trackObjects = 0;
  
  cPriceProtectionScope.klass = rb_define_class_under(mQuickfix, "PriceProtectionScope", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceProtectionScope, (void *) &cPriceProtectionScope);
  rb_define_alloc_func(cPriceProtectionScope.klass, _wrap_PriceProtectionScope_allocate);
  rb_define_method(cPriceProtectionScope.klass, "initialize", VALUEFUNC(_wrap_new_PriceProtectionScope), -1);
  cPriceProtectionScope.mark = 0;
  cPriceProtectionScope.destroy = (void (*)(void *)) free_FIX_PriceProtectionScope;
  cPriceProtectionScope.trackObjects = 0;
  
  cTotNumAssignmentReports.klass = rb_define_class_under(mQuickfix, "TotNumAssignmentReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNumAssignmentReports, (void *) &cTotNumAssignmentReports);
  rb_define_alloc_func(cTotNumAssignmentReports.klass, _wrap_TotNumAssignmentReports_allocate);
  rb_define_method(cTotNumAssignmentReports.klass, "initialize", VALUEFUNC(_wrap_new_TotNumAssignmentReports), -1);
  cTotNumAssignmentReports.mark = 0;
  cTotNumAssignmentReports.destroy = (void (*)(void *)) free_FIX_TotNumAssignmentReports;
  cTotNumAssignmentReports.trackObjects = 0;
  
  cContraLegRefID.klass = rb_define_class_under(mQuickfix, "ContraLegRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraLegRefID, (void *) &cContraLegRefID);
  rb_define_alloc_func(cContraLegRefID.klass, _wrap_ContraLegRefID_allocate);
  rb_define_method(cContraLegRefID.klass, "initialize", VALUEFUNC(_wrap_new_ContraLegRefID), -1);
  cContraLegRefID.mark = 0;
  cContraLegRefID.destroy = (void (*)(void *)) free_FIX_ContraLegRefID;
  cContraLegRefID.trackObjects = 0;
  
  cTradeReportRejectReason.klass = rb_define_class_under(mQuickfix, "TradeReportRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportRejectReason, (void *) &cTradeReportRejectReason);
  rb_define_alloc_func(cTradeReportRejectReason.klass, _wrap_TradeReportRejectReason_allocate);
  rb_define_method(cTradeReportRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportRejectReason), -1);
  cTradeReportRejectReason.mark = 0;
  cTradeReportRejectReason.destroy = (void (*)(void *)) free_FIX_TradeReportRejectReason;
  cTradeReportRejectReason.trackObjects = 0;
  
  cTradeReportRefID.klass = rb_define_class_under(mQuickfix, "TradeReportRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportRefID, (void *) &cTradeReportRefID);
  rb_define_alloc_func(cTradeReportRefID.klass, _wrap_TradeReportRefID_allocate);
  rb_define_method(cTradeReportRefID.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportRefID), -1);
  cTradeReportRefID.mark = 0;
  cTradeReportRefID.destroy = (void (*)(void *)) free_FIX_TradeReportRefID;
  cTradeReportRefID.trackObjects = 0;
  
  cSecurityListType.klass = rb_define_class_under(mQuickfix, "SecurityListType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListType, (void *) &cSecurityListType);
  rb_define_alloc_func(cSecurityListType.klass, _wrap_SecurityListType_allocate);
  rb_define_method(cSecurityListType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListType), -1);
  cSecurityListType.mark = 0;
  cSecurityListType.destroy = (void (*)(void *)) free_FIX_SecurityListType;
  cSecurityListType.trackObjects = 0;
  
  cDerivativeSecurityIDSource.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityIDSource, (void *) &cDerivativeSecurityIDSource);
  rb_define_alloc_func(cDerivativeSecurityIDSource.klass, _wrap_DerivativeSecurityIDSource_allocate);
  rb_define_method(cDerivativeSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityIDSource), -1);
  cDerivativeSecurityIDSource.mark = 0;
  cDerivativeSecurityIDSource.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityIDSource;
  cDerivativeSecurityIDSource.trackObjects = 0;
  
  cAssignmentUnit.klass = rb_define_class_under(mQuickfix, "AssignmentUnit", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AssignmentUnit, (void *) &cAssignmentUnit);
  rb_define_alloc_func(cAssignmentUnit.klass, _wrap_AssignmentUnit_allocate);
  rb_define_method(cAssignmentUnit.klass, "initialize", VALUEFUNC(_wrap_new_AssignmentUnit), -1);
  cAssignmentUnit.mark = 0;
  cAssignmentUnit.destroy = (void (*)(void *)) free_FIX_AssignmentUnit;
  cAssignmentUnit.trackObjects = 0;
  
  cTradeReportID.klass = rb_define_class_under(mQuickfix, "TradeReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportID, (void *) &cTradeReportID);
  rb_define_alloc_func(cTradeReportID.klass, _wrap_TradeReportID_allocate);
  rb_define_method(cTradeReportID.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportID), -1);
  cTradeReportID.mark = 0;
  cTradeReportID.destroy = (void (*)(void *)) free_FIX_TradeReportID;
  cTradeReportID.trackObjects = 0;
  
  cNoRpts.klass = rb_define_class_under(mQuickfix, "NoRpts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRpts, (void *) &cNoRpts);
  rb_define_alloc_func(cNoRpts.klass, _wrap_NoRpts_allocate);
  rb_define_method(cNoRpts.klass, "initialize", VALUEFUNC(_wrap_new_NoRpts), -1);
  cNoRpts.mark = 0;
  cNoRpts.destroy = (void (*)(void *)) free_FIX_NoRpts;
  cNoRpts.trackObjects = 0;
  
  cLegBenchmarkPriceType.klass = rb_define_class_under(mQuickfix, "LegBenchmarkPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkPriceType, (void *) &cLegBenchmarkPriceType);
  rb_define_alloc_func(cLegBenchmarkPriceType.klass, _wrap_LegBenchmarkPriceType_allocate);
  rb_define_method(cLegBenchmarkPriceType.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkPriceType), -1);
  cLegBenchmarkPriceType.mark = 0;
  cLegBenchmarkPriceType.destroy = (void (*)(void *)) free_FIX_LegBenchmarkPriceType;
  cLegBenchmarkPriceType.trackObjects = 0;
  
  cEncodedSubjectLen.klass = rb_define_class_under(mQuickfix, "EncodedSubjectLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSubjectLen, (void *) &cEncodedSubjectLen);
  rb_define_alloc_func(cEncodedSubjectLen.klass, _wrap_EncodedSubjectLen_allocate);
  rb_define_method(cEncodedSubjectLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSubjectLen), -1);
  cEncodedSubjectLen.mark = 0;
  cEncodedSubjectLen.destroy = (void (*)(void *)) free_FIX_EncodedSubjectLen;
  cEncodedSubjectLen.trackObjects = 0;
  
  cSecurityXML.klass = rb_define_class_under(mQuickfix, "SecurityXML", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityXML, (void *) &cSecurityXML);
  rb_define_alloc_func(cSecurityXML.klass, _wrap_SecurityXML_allocate);
  rb_define_method(cSecurityXML.klass, "initialize", VALUEFUNC(_wrap_new_SecurityXML), -1);
  cSecurityXML.mark = 0;
  cSecurityXML.destroy = (void (*)(void *)) free_FIX_SecurityXML;
  cSecurityXML.trackObjects = 0;
  
  cLegReportID.klass = rb_define_class_under(mQuickfix, "LegReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegReportID, (void *) &cLegReportID);
  rb_define_alloc_func(cLegReportID.klass, _wrap_LegReportID_allocate);
  rb_define_method(cLegReportID.klass, "initialize", VALUEFUNC(_wrap_new_LegReportID), -1);
  cLegReportID.mark = 0;
  cLegReportID.destroy = (void (*)(void *)) free_FIX_LegReportID;
  cLegReportID.trackObjects = 0;
  
  cNested3PartySubIDType.klass = rb_define_class_under(mQuickfix, "Nested3PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartySubIDType, (void *) &cNested3PartySubIDType);
  rb_define_alloc_func(cNested3PartySubIDType.klass, _wrap_Nested3PartySubIDType_allocate);
  rb_define_method(cNested3PartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartySubIDType), -1);
  cNested3PartySubIDType.mark = 0;
  cNested3PartySubIDType.destroy = (void (*)(void *)) free_FIX_Nested3PartySubIDType;
  cNested3PartySubIDType.trackObjects = 0;
  
  cBenchmarkSecurityIDSource.klass = rb_define_class_under(mQuickfix, "BenchmarkSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkSecurityIDSource, (void *) &cBenchmarkSecurityIDSource);
  rb_define_alloc_func(cBenchmarkSecurityIDSource.klass, _wrap_BenchmarkSecurityIDSource_allocate);
  rb_define_method(cBenchmarkSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkSecurityIDSource), -1);
  cBenchmarkSecurityIDSource.mark = 0;
  cBenchmarkSecurityIDSource.destroy = (void (*)(void *)) free_FIX_BenchmarkSecurityIDSource;
  cBenchmarkSecurityIDSource.trackObjects = 0;
  
  cQuoteRejectReason.klass = rb_define_class_under(mQuickfix, "QuoteRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRejectReason, (void *) &cQuoteRejectReason);
  rb_define_alloc_func(cQuoteRejectReason.klass, _wrap_QuoteRejectReason_allocate);
  rb_define_method(cQuoteRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRejectReason), -1);
  cQuoteRejectReason.mark = 0;
  cQuoteRejectReason.destroy = (void (*)(void *)) free_FIX_QuoteRejectReason;
  cQuoteRejectReason.trackObjects = 0;
  
  cHeartBtInt.klass = rb_define_class_under(mQuickfix, "HeartBtInt", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HeartBtInt, (void *) &cHeartBtInt);
  rb_define_alloc_func(cHeartBtInt.klass, _wrap_HeartBtInt_allocate);
  rb_define_method(cHeartBtInt.klass, "initialize", VALUEFUNC(_wrap_new_HeartBtInt), -1);
  cHeartBtInt.mark = 0;
  cHeartBtInt.destroy = (void (*)(void *)) free_FIX_HeartBtInt;
  cHeartBtInt.trackObjects = 0;
  
  cBidForwardPoints.klass = rb_define_class_under(mQuickfix, "BidForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidForwardPoints, (void *) &cBidForwardPoints);
  rb_define_alloc_func(cBidForwardPoints.klass, _wrap_BidForwardPoints_allocate);
  rb_define_method(cBidForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_BidForwardPoints), -1);
  cBidForwardPoints.mark = 0;
  cBidForwardPoints.destroy = (void (*)(void *)) free_FIX_BidForwardPoints;
  cBidForwardPoints.trackObjects = 0;
  
  cPossResend.klass = rb_define_class_under(mQuickfix, "PossResend", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PossResend, (void *) &cPossResend);
  rb_define_alloc_func(cPossResend.klass, _wrap_PossResend_allocate);
  rb_define_method(cPossResend.klass, "initialize", VALUEFUNC(_wrap_new_PossResend), -1);
  cPossResend.mark = 0;
  cPossResend.destroy = (void (*)(void *)) free_FIX_PossResend;
  cPossResend.trackObjects = 0;
  
  cSymbol.klass = rb_define_class_under(mQuickfix, "Symbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Symbol, (void *) &cSymbol);
  rb_define_alloc_func(cSymbol.klass, _wrap_Symbol_allocate);
  rb_define_method(cSymbol.klass, "initialize", VALUEFUNC(_wrap_new_Symbol), -1);
  cSymbol.mark = 0;
  cSymbol.destroy = (void (*)(void *)) free_FIX_Symbol;
  cSymbol.trackObjects = 0;
  
  cEncodedUnderlyingSecurityDesc.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDesc, (void *) &cEncodedUnderlyingSecurityDesc);
  rb_define_alloc_func(cEncodedUnderlyingSecurityDesc.klass, _wrap_EncodedUnderlyingSecurityDesc_allocate);
  rb_define_method(cEncodedUnderlyingSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingSecurityDesc), -1);
  cEncodedUnderlyingSecurityDesc.mark = 0;
  cEncodedUnderlyingSecurityDesc.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingSecurityDesc;
  cEncodedUnderlyingSecurityDesc.trackObjects = 0;
  
  cRelatedPartyAltSubIDType.klass = rb_define_class_under(mQuickfix, "RelatedPartyAltSubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartyAltSubIDType, (void *) &cRelatedPartyAltSubIDType);
  rb_define_alloc_func(cRelatedPartyAltSubIDType.klass, _wrap_RelatedPartyAltSubIDType_allocate);
  rb_define_method(cRelatedPartyAltSubIDType.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartyAltSubIDType), -1);
  cRelatedPartyAltSubIDType.mark = 0;
  cRelatedPartyAltSubIDType.destroy = (void (*)(void *)) free_FIX_RelatedPartyAltSubIDType;
  cRelatedPartyAltSubIDType.trackObjects = 0;
  
  cMarketReportID.klass = rb_define_class_under(mQuickfix, "MarketReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketReportID, (void *) &cMarketReportID);
  rb_define_alloc_func(cMarketReportID.klass, _wrap_MarketReportID_allocate);
  rb_define_method(cMarketReportID.klass, "initialize", VALUEFUNC(_wrap_new_MarketReportID), -1);
  cMarketReportID.mark = 0;
  cMarketReportID.destroy = (void (*)(void *)) free_FIX_MarketReportID;
  cMarketReportID.trackObjects = 0;
  
  cDiscretionPrice.klass = rb_define_class_under(mQuickfix, "DiscretionPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionPrice, (void *) &cDiscretionPrice);
  rb_define_alloc_func(cDiscretionPrice.klass, _wrap_DiscretionPrice_allocate);
  rb_define_method(cDiscretionPrice.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionPrice), -1);
  cDiscretionPrice.mark = 0;
  cDiscretionPrice.destroy = (void (*)(void *)) free_FIX_DiscretionPrice;
  cDiscretionPrice.trackObjects = 0;
  
  cContAmtValue.klass = rb_define_class_under(mQuickfix, "ContAmtValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContAmtValue, (void *) &cContAmtValue);
  rb_define_alloc_func(cContAmtValue.klass, _wrap_ContAmtValue_allocate);
  rb_define_method(cContAmtValue.klass, "initialize", VALUEFUNC(_wrap_new_ContAmtValue), -1);
  cContAmtValue.mark = 0;
  cContAmtValue.destroy = (void (*)(void *)) free_FIX_ContAmtValue;
  cContAmtValue.trackObjects = 0;
  
  cQuantityType.klass = rb_define_class_under(mQuickfix, "QuantityType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuantityType, (void *) &cQuantityType);
  rb_define_alloc_func(cQuantityType.klass, _wrap_QuantityType_allocate);
  rb_define_method(cQuantityType.klass, "initialize", VALUEFUNC(_wrap_new_QuantityType), -1);
  cQuantityType.mark = 0;
  cQuantityType.destroy = (void (*)(void *)) free_FIX_QuantityType;
  cQuantityType.trackObjects = 0;
  
  cComplexEventPriceBoundaryMethod.klass = rb_define_class_under(mQuickfix, "ComplexEventPriceBoundaryMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPriceBoundaryMethod, (void *) &cComplexEventPriceBoundaryMethod);
  rb_define_alloc_func(cComplexEventPriceBoundaryMethod.klass, _wrap_ComplexEventPriceBoundaryMethod_allocate);
  rb_define_method(cComplexEventPriceBoundaryMethod.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPriceBoundaryMethod), -1);
  cComplexEventPriceBoundaryMethod.mark = 0;
  cComplexEventPriceBoundaryMethod.destroy = (void (*)(void *)) free_FIX_ComplexEventPriceBoundaryMethod;
  cComplexEventPriceBoundaryMethod.trackObjects = 0;
  
  cImpliedMarketIndicator.klass = rb_define_class_under(mQuickfix, "ImpliedMarketIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ImpliedMarketIndicator, (void *) &cImpliedMarketIndicator);
  rb_define_alloc_func(cImpliedMarketIndicator.klass, _wrap_ImpliedMarketIndicator_allocate);
  rb_define_method(cImpliedMarketIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ImpliedMarketIndicator), -1);
  cImpliedMarketIndicator.mark = 0;
  cImpliedMarketIndicator.destroy = (void (*)(void *)) free_FIX_ImpliedMarketIndicator;
  cImpliedMarketIndicator.trackObjects = 0;
  
  cAllocClearingFeeIndicator.klass = rb_define_class_under(mQuickfix, "AllocClearingFeeIndicator", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocClearingFeeIndicator, (void *) &cAllocClearingFeeIndicator);
  rb_define_alloc_func(cAllocClearingFeeIndicator.klass, _wrap_AllocClearingFeeIndicator_allocate);
  rb_define_method(cAllocClearingFeeIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AllocClearingFeeIndicator), -1);
  cAllocClearingFeeIndicator.mark = 0;
  cAllocClearingFeeIndicator.destroy = (void (*)(void *)) free_FIX_AllocClearingFeeIndicator;
  cAllocClearingFeeIndicator.trackObjects = 0;
  
  cQuoteRequestType.klass = rb_define_class_under(mQuickfix, "QuoteRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRequestType, (void *) &cQuoteRequestType);
  rb_define_alloc_func(cQuoteRequestType.klass, _wrap_QuoteRequestType_allocate);
  rb_define_method(cQuoteRequestType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRequestType), -1);
  cQuoteRequestType.mark = 0;
  cQuoteRequestType.destroy = (void (*)(void *)) free_FIX_QuoteRequestType;
  cQuoteRequestType.trackObjects = 0;
  
  cSecurityRequestResult.klass = rb_define_class_under(mQuickfix, "SecurityRequestResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityRequestResult, (void *) &cSecurityRequestResult);
  rb_define_alloc_func(cSecurityRequestResult.klass, _wrap_SecurityRequestResult_allocate);
  rb_define_method(cSecurityRequestResult.klass, "initialize", VALUEFUNC(_wrap_new_SecurityRequestResult), -1);
  cSecurityRequestResult.mark = 0;
  cSecurityRequestResult.destroy = (void (*)(void *)) free_FIX_SecurityRequestResult;
  cSecurityRequestResult.trackObjects = 0;
  
  cOrderRestrictions.klass = rb_define_class_under(mQuickfix, "OrderRestrictions", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderRestrictions, (void *) &cOrderRestrictions);
  rb_define_alloc_func(cOrderRestrictions.klass, _wrap_OrderRestrictions_allocate);
  rb_define_method(cOrderRestrictions.klass, "initialize", VALUEFUNC(_wrap_new_OrderRestrictions), -1);
  cOrderRestrictions.mark = 0;
  cOrderRestrictions.destroy = (void (*)(void *)) free_FIX_OrderRestrictions;
  cOrderRestrictions.trackObjects = 0;
  
  cNoSideTrdRegTS.klass = rb_define_class_under(mQuickfix, "NoSideTrdRegTS", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSideTrdRegTS, (void *) &cNoSideTrdRegTS);
  rb_define_alloc_func(cNoSideTrdRegTS.klass, _wrap_NoSideTrdRegTS_allocate);
  rb_define_method(cNoSideTrdRegTS.klass, "initialize", VALUEFUNC(_wrap_new_NoSideTrdRegTS), -1);
  cNoSideTrdRegTS.mark = 0;
  cNoSideTrdRegTS.destroy = (void (*)(void *)) free_FIX_NoSideTrdRegTS;
  cNoSideTrdRegTS.trackObjects = 0;
  
  cText.klass = rb_define_class_under(mQuickfix, "Text", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Text, (void *) &cText);
  rb_define_alloc_func(cText.klass, _wrap_Text_allocate);
  rb_define_method(cText.klass, "initialize", VALUEFUNC(_wrap_new_Text), -1);
  cText.mark = 0;
  cText.destroy = (void (*)(void *)) free_FIX_Text;
  cText.trackObjects = 0;
  
  cEncodedTextLen.klass = rb_define_class_under(mQuickfix, "EncodedTextLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedTextLen, (void *) &cEncodedTextLen);
  rb_define_alloc_func(cEncodedTextLen.klass, _wrap_EncodedTextLen_allocate);
  rb_define_method(cEncodedTextLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedTextLen), -1);
  cEncodedTextLen.mark = 0;
  cEncodedTextLen.destroy = (void (*)(void *)) free_FIX_EncodedTextLen;
  cEncodedTextLen.trackObjects = 0;
  
  cListExecInstType.klass = rb_define_class_under(mQuickfix, "ListExecInstType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListExecInstType, (void *) &cListExecInstType);
  rb_define_alloc_func(cListExecInstType.klass, _wrap_ListExecInstType_allocate);
  rb_define_method(cListExecInstType.klass, "initialize", VALUEFUNC(_wrap_new_ListExecInstType), -1);
  cListExecInstType.mark = 0;
  cListExecInstType.destroy = (void (*)(void *)) free_FIX_ListExecInstType;
  cListExecInstType.trackObjects = 0;
  
  cSecondaryOrderID.klass = rb_define_class_under(mQuickfix, "SecondaryOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryOrderID, (void *) &cSecondaryOrderID);
  rb_define_alloc_func(cSecondaryOrderID.klass, _wrap_SecondaryOrderID_allocate);
  rb_define_method(cSecondaryOrderID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryOrderID), -1);
  cSecondaryOrderID.mark = 0;
  cSecondaryOrderID.destroy = (void (*)(void *)) free_FIX_SecondaryOrderID;
  cSecondaryOrderID.trackObjects = 0;
  
  cExecBroker.klass = rb_define_class_under(mQuickfix, "ExecBroker", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecBroker, (void *) &cExecBroker);
  rb_define_alloc_func(cExecBroker.klass, _wrap_ExecBroker_allocate);
  rb_define_method(cExecBroker.klass, "initialize", VALUEFUNC(_wrap_new_ExecBroker), -1);
  cExecBroker.mark = 0;
  cExecBroker.destroy = (void (*)(void *)) free_FIX_ExecBroker;
  cExecBroker.trackObjects = 0;
  
  cRelationshipRiskEncodedSecurityDescLen.klass = rb_define_class_under(mQuickfix, "RelationshipRiskEncodedSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskEncodedSecurityDescLen, (void *) &cRelationshipRiskEncodedSecurityDescLen);
  rb_define_alloc_func(cRelationshipRiskEncodedSecurityDescLen.klass, _wrap_RelationshipRiskEncodedSecurityDescLen_allocate);
  rb_define_method(cRelationshipRiskEncodedSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskEncodedSecurityDescLen), -1);
  cRelationshipRiskEncodedSecurityDescLen.mark = 0;
  cRelationshipRiskEncodedSecurityDescLen.destroy = (void (*)(void *)) free_FIX_RelationshipRiskEncodedSecurityDescLen;
  cRelationshipRiskEncodedSecurityDescLen.trackObjects = 0;
  
  cSecurityXMLLen.klass = rb_define_class_under(mQuickfix, "SecurityXMLLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityXMLLen, (void *) &cSecurityXMLLen);
  rb_define_alloc_func(cSecurityXMLLen.klass, _wrap_SecurityXMLLen_allocate);
  rb_define_method(cSecurityXMLLen.klass, "initialize", VALUEFUNC(_wrap_new_SecurityXMLLen), -1);
  cSecurityXMLLen.mark = 0;
  cSecurityXMLLen.destroy = (void (*)(void *)) free_FIX_SecurityXMLLen;
  cSecurityXMLLen.trackObjects = 0;
  
  cApplSeqNum.klass = rb_define_class_under(mQuickfix, "ApplSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplSeqNum, (void *) &cApplSeqNum);
  rb_define_alloc_func(cApplSeqNum.klass, _wrap_ApplSeqNum_allocate);
  rb_define_method(cApplSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplSeqNum), -1);
  cApplSeqNum.mark = 0;
  cApplSeqNum.destroy = (void (*)(void *)) free_FIX_ApplSeqNum;
  cApplSeqNum.trackObjects = 0;
  
  cMaxTradeVol.klass = rb_define_class_under(mQuickfix, "MaxTradeVol", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxTradeVol, (void *) &cMaxTradeVol);
  rb_define_alloc_func(cMaxTradeVol.klass, _wrap_MaxTradeVol_allocate);
  rb_define_method(cMaxTradeVol.klass, "initialize", VALUEFUNC(_wrap_new_MaxTradeVol), -1);
  cMaxTradeVol.mark = 0;
  cMaxTradeVol.destroy = (void (*)(void *)) free_FIX_MaxTradeVol;
  cMaxTradeVol.trackObjects = 0;
  
  cOfferSwapPoints.klass = rb_define_class_under(mQuickfix, "OfferSwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferSwapPoints, (void *) &cOfferSwapPoints);
  rb_define_alloc_func(cOfferSwapPoints.klass, _wrap_OfferSwapPoints_allocate);
  rb_define_method(cOfferSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_OfferSwapPoints), -1);
  cOfferSwapPoints.mark = 0;
  cOfferSwapPoints.destroy = (void (*)(void *)) free_FIX_OfferSwapPoints;
  cOfferSwapPoints.trackObjects = 0;
  
  cSettlPartySubIDType.klass = rb_define_class_under(mQuickfix, "SettlPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartySubIDType, (void *) &cSettlPartySubIDType);
  rb_define_alloc_func(cSettlPartySubIDType.klass, _wrap_SettlPartySubIDType_allocate);
  rb_define_method(cSettlPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartySubIDType), -1);
  cSettlPartySubIDType.mark = 0;
  cSettlPartySubIDType.destroy = (void (*)(void *)) free_FIX_SettlPartySubIDType;
  cSettlPartySubIDType.trackObjects = 0;
  
  cDistribPaymentMethod.klass = rb_define_class_under(mQuickfix, "DistribPaymentMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DistribPaymentMethod, (void *) &cDistribPaymentMethod);
  rb_define_alloc_func(cDistribPaymentMethod.klass, _wrap_DistribPaymentMethod_allocate);
  rb_define_method(cDistribPaymentMethod.klass, "initialize", VALUEFUNC(_wrap_new_DistribPaymentMethod), -1);
  cDistribPaymentMethod.mark = 0;
  cDistribPaymentMethod.destroy = (void (*)(void *)) free_FIX_DistribPaymentMethod;
  cDistribPaymentMethod.trackObjects = 0;
  
  cTotalAffectedOrders.klass = rb_define_class_under(mQuickfix, "TotalAffectedOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalAffectedOrders, (void *) &cTotalAffectedOrders);
  rb_define_alloc_func(cTotalAffectedOrders.klass, _wrap_TotalAffectedOrders_allocate);
  rb_define_method(cTotalAffectedOrders.klass, "initialize", VALUEFUNC(_wrap_new_TotalAffectedOrders), -1);
  cTotalAffectedOrders.mark = 0;
  cTotalAffectedOrders.destroy = (void (*)(void *)) free_FIX_TotalAffectedOrders;
  cTotalAffectedOrders.trackObjects = 0;
  
  cStrikeIncrement.klass = rb_define_class_under(mQuickfix, "StrikeIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeIncrement, (void *) &cStrikeIncrement);
  rb_define_alloc_func(cStrikeIncrement.klass, _wrap_StrikeIncrement_allocate);
  rb_define_method(cStrikeIncrement.klass, "initialize", VALUEFUNC(_wrap_new_StrikeIncrement), -1);
  cStrikeIncrement.mark = 0;
  cStrikeIncrement.destroy = (void (*)(void *)) free_FIX_StrikeIncrement;
  cStrikeIncrement.trackObjects = 0;
  
  cOrderHandlingInstSource.klass = rb_define_class_under(mQuickfix, "OrderHandlingInstSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderHandlingInstSource, (void *) &cOrderHandlingInstSource);
  rb_define_alloc_func(cOrderHandlingInstSource.klass, _wrap_OrderHandlingInstSource_allocate);
  rb_define_method(cOrderHandlingInstSource.klass, "initialize", VALUEFUNC(_wrap_new_OrderHandlingInstSource), -1);
  cOrderHandlingInstSource.mark = 0;
  cOrderHandlingInstSource.destroy = (void (*)(void *)) free_FIX_OrderHandlingInstSource;
  cOrderHandlingInstSource.trackObjects = 0;
  
  cCopyMsgIndicator.klass = rb_define_class_under(mQuickfix, "CopyMsgIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CopyMsgIndicator, (void *) &cCopyMsgIndicator);
  rb_define_alloc_func(cCopyMsgIndicator.klass, _wrap_CopyMsgIndicator_allocate);
  rb_define_method(cCopyMsgIndicator.klass, "initialize", VALUEFUNC(_wrap_new_CopyMsgIndicator), -1);
  cCopyMsgIndicator.mark = 0;
  cCopyMsgIndicator.destroy = (void (*)(void *)) free_FIX_CopyMsgIndicator;
  cCopyMsgIndicator.trackObjects = 0;
  
  cNoDlvyInst.klass = rb_define_class_under(mQuickfix, "NoDlvyInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDlvyInst, (void *) &cNoDlvyInst);
  rb_define_alloc_func(cNoDlvyInst.klass, _wrap_NoDlvyInst_allocate);
  rb_define_method(cNoDlvyInst.klass, "initialize", VALUEFUNC(_wrap_new_NoDlvyInst), -1);
  cNoDlvyInst.mark = 0;
  cNoDlvyInst.destroy = (void (*)(void *)) free_FIX_NoDlvyInst;
  cNoDlvyInst.trackObjects = 0;
  
  cQuoteEntryID.klass = rb_define_class_under(mQuickfix, "QuoteEntryID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteEntryID, (void *) &cQuoteEntryID);
  rb_define_alloc_func(cQuoteEntryID.klass, _wrap_QuoteEntryID_allocate);
  rb_define_method(cQuoteEntryID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteEntryID), -1);
  cQuoteEntryID.mark = 0;
  cQuoteEntryID.destroy = (void (*)(void *)) free_FIX_QuoteEntryID;
  cQuoteEntryID.trackObjects = 0;
  
  cAffirmStatus.klass = rb_define_class_under(mQuickfix, "AffirmStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AffirmStatus, (void *) &cAffirmStatus);
  rb_define_alloc_func(cAffirmStatus.klass, _wrap_AffirmStatus_allocate);
  rb_define_method(cAffirmStatus.klass, "initialize", VALUEFUNC(_wrap_new_AffirmStatus), -1);
  cAffirmStatus.mark = 0;
  cAffirmStatus.destroy = (void (*)(void *)) free_FIX_AffirmStatus;
  cAffirmStatus.trackObjects = 0;
  
  cMailingInst.klass = rb_define_class_under(mQuickfix, "MailingInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MailingInst, (void *) &cMailingInst);
  rb_define_alloc_func(cMailingInst.klass, _wrap_MailingInst_allocate);
  rb_define_method(cMailingInst.klass, "initialize", VALUEFUNC(_wrap_new_MailingInst), -1);
  cMailingInst.mark = 0;
  cMailingInst.destroy = (void (*)(void *)) free_FIX_MailingInst;
  cMailingInst.trackObjects = 0;
  
  cOfferSize.klass = rb_define_class_under(mQuickfix, "OfferSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferSize, (void *) &cOfferSize);
  rb_define_alloc_func(cOfferSize.klass, _wrap_OfferSize_allocate);
  rb_define_method(cOfferSize.klass, "initialize", VALUEFUNC(_wrap_new_OfferSize), -1);
  cOfferSize.mark = 0;
  cOfferSize.destroy = (void (*)(void *)) free_FIX_OfferSize;
  cOfferSize.trackObjects = 0;
  
  cLegSecurityType.klass = rb_define_class_under(mQuickfix, "LegSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityType, (void *) &cLegSecurityType);
  rb_define_alloc_func(cLegSecurityType.klass, _wrap_LegSecurityType_allocate);
  rb_define_method(cLegSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityType), -1);
  cLegSecurityType.mark = 0;
  cLegSecurityType.destroy = (void (*)(void *)) free_FIX_LegSecurityType;
  cLegSecurityType.trackObjects = 0;
  
  cRiskLimitPlatform.klass = rb_define_class_under(mQuickfix, "RiskLimitPlatform", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskLimitPlatform, (void *) &cRiskLimitPlatform);
  rb_define_alloc_func(cRiskLimitPlatform.klass, _wrap_RiskLimitPlatform_allocate);
  rb_define_method(cRiskLimitPlatform.klass, "initialize", VALUEFUNC(_wrap_new_RiskLimitPlatform), -1);
  cRiskLimitPlatform.mark = 0;
  cRiskLimitPlatform.destroy = (void (*)(void *)) free_FIX_RiskLimitPlatform;
  cRiskLimitPlatform.trackObjects = 0;
  
  cOrigCustOrderCapacity.klass = rb_define_class_under(mQuickfix, "OrigCustOrderCapacity", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigCustOrderCapacity, (void *) &cOrigCustOrderCapacity);
  rb_define_alloc_func(cOrigCustOrderCapacity.klass, _wrap_OrigCustOrderCapacity_allocate);
  rb_define_method(cOrigCustOrderCapacity.klass, "initialize", VALUEFUNC(_wrap_new_OrigCustOrderCapacity), -1);
  cOrigCustOrderCapacity.mark = 0;
  cOrigCustOrderCapacity.destroy = (void (*)(void *)) free_FIX_OrigCustOrderCapacity;
  cOrigCustOrderCapacity.trackObjects = 0;
  
  cAllocMethod.klass = rb_define_class_under(mQuickfix, "AllocMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocMethod, (void *) &cAllocMethod);
  rb_define_alloc_func(cAllocMethod.klass, _wrap_AllocMethod_allocate);
  rb_define_method(cAllocMethod.klass, "initialize", VALUEFUNC(_wrap_new_AllocMethod), -1);
  cAllocMethod.mark = 0;
  cAllocMethod.destroy = (void (*)(void *)) free_FIX_AllocMethod;
  cAllocMethod.trackObjects = 0;
  
  cQuantityDate.klass = rb_define_class_under(mQuickfix, "QuantityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuantityDate, (void *) &cQuantityDate);
  rb_define_alloc_func(cQuantityDate.klass, _wrap_QuantityDate_allocate);
  rb_define_method(cQuantityDate.klass, "initialize", VALUEFUNC(_wrap_new_QuantityDate), -1);
  cQuantityDate.mark = 0;
  cQuantityDate.destroy = (void (*)(void *)) free_FIX_QuantityDate;
  cQuantityDate.trackObjects = 0;
  
  cTargetStrategyPerformance.klass = rb_define_class_under(mQuickfix, "TargetStrategyPerformance", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetStrategyPerformance, (void *) &cTargetStrategyPerformance);
  rb_define_alloc_func(cTargetStrategyPerformance.klass, _wrap_TargetStrategyPerformance_allocate);
  rb_define_method(cTargetStrategyPerformance.klass, "initialize", VALUEFUNC(_wrap_new_TargetStrategyPerformance), -1);
  cTargetStrategyPerformance.mark = 0;
  cTargetStrategyPerformance.destroy = (void (*)(void *)) free_FIX_TargetStrategyPerformance;
  cTargetStrategyPerformance.trackObjects = 0;
  
  cCardExpDate.klass = rb_define_class_under(mQuickfix, "CardExpDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardExpDate, (void *) &cCardExpDate);
  rb_define_alloc_func(cCardExpDate.klass, _wrap_CardExpDate_allocate);
  rb_define_method(cCardExpDate.klass, "initialize", VALUEFUNC(_wrap_new_CardExpDate), -1);
  cCardExpDate.mark = 0;
  cCardExpDate.destroy = (void (*)(void *)) free_FIX_CardExpDate;
  cCardExpDate.trackObjects = 0;
  
  cConfirmID.klass = rb_define_class_under(mQuickfix, "ConfirmID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmID, (void *) &cConfirmID);
  rb_define_alloc_func(cConfirmID.klass, _wrap_ConfirmID_allocate);
  rb_define_method(cConfirmID.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmID), -1);
  cConfirmID.mark = 0;
  cConfirmID.destroy = (void (*)(void *)) free_FIX_ConfirmID;
  cConfirmID.trackObjects = 0;
  
  cStandInstDbName.klass = rb_define_class_under(mQuickfix, "StandInstDbName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StandInstDbName, (void *) &cStandInstDbName);
  rb_define_alloc_func(cStandInstDbName.klass, _wrap_StandInstDbName_allocate);
  rb_define_method(cStandInstDbName.klass, "initialize", VALUEFUNC(_wrap_new_StandInstDbName), -1);
  cStandInstDbName.mark = 0;
  cStandInstDbName.destroy = (void (*)(void *)) free_FIX_StandInstDbName;
  cStandInstDbName.trackObjects = 0;
  
  cDayOrderQty.klass = rb_define_class_under(mQuickfix, "DayOrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayOrderQty, (void *) &cDayOrderQty);
  rb_define_alloc_func(cDayOrderQty.klass, _wrap_DayOrderQty_allocate);
  rb_define_method(cDayOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_DayOrderQty), -1);
  cDayOrderQty.mark = 0;
  cDayOrderQty.destroy = (void (*)(void *)) free_FIX_DayOrderQty;
  cDayOrderQty.trackObjects = 0;
  
  cHighLimitPrice.klass = rb_define_class_under(mQuickfix, "HighLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HighLimitPrice, (void *) &cHighLimitPrice);
  rb_define_alloc_func(cHighLimitPrice.klass, _wrap_HighLimitPrice_allocate);
  rb_define_method(cHighLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_HighLimitPrice), -1);
  cHighLimitPrice.mark = 0;
  cHighLimitPrice.destroy = (void (*)(void *)) free_FIX_HighLimitPrice;
  cHighLimitPrice.trackObjects = 0;
  
  cFirmTradeID.klass = rb_define_class_under(mQuickfix, "FirmTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FirmTradeID, (void *) &cFirmTradeID);
  rb_define_alloc_func(cFirmTradeID.klass, _wrap_FirmTradeID_allocate);
  rb_define_method(cFirmTradeID.klass, "initialize", VALUEFUNC(_wrap_new_FirmTradeID), -1);
  cFirmTradeID.mark = 0;
  cFirmTradeID.destroy = (void (*)(void *)) free_FIX_FirmTradeID;
  cFirmTradeID.trackObjects = 0;
  
  cSecondaryIndividualAllocID.klass = rb_define_class_under(mQuickfix, "SecondaryIndividualAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryIndividualAllocID, (void *) &cSecondaryIndividualAllocID);
  rb_define_alloc_func(cSecondaryIndividualAllocID.klass, _wrap_SecondaryIndividualAllocID_allocate);
  rb_define_method(cSecondaryIndividualAllocID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryIndividualAllocID), -1);
  cSecondaryIndividualAllocID.mark = 0;
  cSecondaryIndividualAllocID.destroy = (void (*)(void *)) free_FIX_SecondaryIndividualAllocID;
  cSecondaryIndividualAllocID.trackObjects = 0;
  
  cAgreementDesc.klass = rb_define_class_under(mQuickfix, "AgreementDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementDesc, (void *) &cAgreementDesc);
  rb_define_alloc_func(cAgreementDesc.klass, _wrap_AgreementDesc_allocate);
  rb_define_method(cAgreementDesc.klass, "initialize", VALUEFUNC(_wrap_new_AgreementDesc), -1);
  cAgreementDesc.mark = 0;
  cAgreementDesc.destroy = (void (*)(void *)) free_FIX_AgreementDesc;
  cAgreementDesc.trackObjects = 0;
  
  cMassCancelResponse.klass = rb_define_class_under(mQuickfix, "MassCancelResponse", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassCancelResponse, (void *) &cMassCancelResponse);
  rb_define_alloc_func(cMassCancelResponse.klass, _wrap_MassCancelResponse_allocate);
  rb_define_method(cMassCancelResponse.klass, "initialize", VALUEFUNC(_wrap_new_MassCancelResponse), -1);
  cMassCancelResponse.mark = 0;
  cMassCancelResponse.destroy = (void (*)(void *)) free_FIX_MassCancelResponse;
  cMassCancelResponse.trackObjects = 0;
  
  cLegSettlCurrency.klass = rb_define_class_under(mQuickfix, "LegSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlCurrency, (void *) &cLegSettlCurrency);
  rb_define_alloc_func(cLegSettlCurrency.klass, _wrap_LegSettlCurrency_allocate);
  rb_define_method(cLegSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlCurrency), -1);
  cLegSettlCurrency.mark = 0;
  cLegSettlCurrency.destroy = (void (*)(void *)) free_FIX_LegSettlCurrency;
  cLegSettlCurrency.trackObjects = 0;
  
  cCommission.klass = rb_define_class_under(mQuickfix, "Commission", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Commission, (void *) &cCommission);
  rb_define_alloc_func(cCommission.klass, _wrap_Commission_allocate);
  rb_define_method(cCommission.klass, "initialize", VALUEFUNC(_wrap_new_Commission), -1);
  cCommission.mark = 0;
  cCommission.destroy = (void (*)(void *)) free_FIX_Commission;
  cCommission.trackObjects = 0;
  
  cStreamAsgnReqType.klass = rb_define_class_under(mQuickfix, "StreamAsgnReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnReqType, (void *) &cStreamAsgnReqType);
  rb_define_alloc_func(cStreamAsgnReqType.klass, _wrap_StreamAsgnReqType_allocate);
  rb_define_method(cStreamAsgnReqType.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnReqType), -1);
  cStreamAsgnReqType.mark = 0;
  cStreamAsgnReqType.destroy = (void (*)(void *)) free_FIX_StreamAsgnReqType;
  cStreamAsgnReqType.trackObjects = 0;
  
  cBidSwapPoints.klass = rb_define_class_under(mQuickfix, "BidSwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidSwapPoints, (void *) &cBidSwapPoints);
  rb_define_alloc_func(cBidSwapPoints.klass, _wrap_BidSwapPoints_allocate);
  rb_define_method(cBidSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_BidSwapPoints), -1);
  cBidSwapPoints.mark = 0;
  cBidSwapPoints.destroy = (void (*)(void *)) free_FIX_BidSwapPoints;
  cBidSwapPoints.trackObjects = 0;
  
  cNoSettlPartyIDs.klass = rb_define_class_under(mQuickfix, "NoSettlPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlPartyIDs, (void *) &cNoSettlPartyIDs);
  rb_define_alloc_func(cNoSettlPartyIDs.klass, _wrap_NoSettlPartyIDs_allocate);
  rb_define_method(cNoSettlPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlPartyIDs), -1);
  cNoSettlPartyIDs.mark = 0;
  cNoSettlPartyIDs.destroy = (void (*)(void *)) free_FIX_NoSettlPartyIDs;
  cNoSettlPartyIDs.trackObjects = 0;
  
  cSymbolSfx.klass = rb_define_class_under(mQuickfix, "SymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SymbolSfx, (void *) &cSymbolSfx);
  rb_define_alloc_func(cSymbolSfx.klass, _wrap_SymbolSfx_allocate);
  rb_define_method(cSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_SymbolSfx), -1);
  cSymbolSfx.mark = 0;
  cSymbolSfx.destroy = (void (*)(void *)) free_FIX_SymbolSfx;
  cSymbolSfx.trackObjects = 0;
  
  cBusinessRejectRefID.klass = rb_define_class_under(mQuickfix, "BusinessRejectRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BusinessRejectRefID, (void *) &cBusinessRejectRefID);
  rb_define_alloc_func(cBusinessRejectRefID.klass, _wrap_BusinessRejectRefID_allocate);
  rb_define_method(cBusinessRejectRefID.klass, "initialize", VALUEFUNC(_wrap_new_BusinessRejectRefID), -1);
  cBusinessRejectRefID.mark = 0;
  cBusinessRejectRefID.destroy = (void (*)(void *)) free_FIX_BusinessRejectRefID;
  cBusinessRejectRefID.trackObjects = 0;
  
  cPrice2.klass = rb_define_class_under(mQuickfix, "Price2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Price2, (void *) &cPrice2);
  rb_define_alloc_func(cPrice2.klass, _wrap_Price2_allocate);
  rb_define_method(cPrice2.klass, "initialize", VALUEFUNC(_wrap_new_Price2), -1);
  cPrice2.mark = 0;
  cPrice2.destroy = (void (*)(void *)) free_FIX_Price2;
  cPrice2.trackObjects = 0;
  
  cFillLiquidityInd.klass = rb_define_class_under(mQuickfix, "FillLiquidityInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillLiquidityInd, (void *) &cFillLiquidityInd);
  rb_define_alloc_func(cFillLiquidityInd.klass, _wrap_FillLiquidityInd_allocate);
  rb_define_method(cFillLiquidityInd.klass, "initialize", VALUEFUNC(_wrap_new_FillLiquidityInd), -1);
  cFillLiquidityInd.mark = 0;
  cFillLiquidityInd.destroy = (void (*)(void *)) free_FIX_FillLiquidityInd;
  cFillLiquidityInd.trackObjects = 0;
  
  cMassActionReportID.klass = rb_define_class_under(mQuickfix, "MassActionReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionReportID, (void *) &cMassActionReportID);
  rb_define_alloc_func(cMassActionReportID.klass, _wrap_MassActionReportID_allocate);
  rb_define_method(cMassActionReportID.klass, "initialize", VALUEFUNC(_wrap_new_MassActionReportID), -1);
  cMassActionReportID.mark = 0;
  cMassActionReportID.destroy = (void (*)(void *)) free_FIX_MassActionReportID;
  cMassActionReportID.trackObjects = 0;
  
  cDerivativeIssuer.klass = rb_define_class_under(mQuickfix, "DerivativeIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeIssuer, (void *) &cDerivativeIssuer);
  rb_define_alloc_func(cDerivativeIssuer.klass, _wrap_DerivativeIssuer_allocate);
  rb_define_method(cDerivativeIssuer.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeIssuer), -1);
  cDerivativeIssuer.mark = 0;
  cDerivativeIssuer.destroy = (void (*)(void *)) free_FIX_DerivativeIssuer;
  cDerivativeIssuer.trackObjects = 0;
  
  cExDestinationIDSource.klass = rb_define_class_under(mQuickfix, "ExDestinationIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExDestinationIDSource, (void *) &cExDestinationIDSource);
  rb_define_alloc_func(cExDestinationIDSource.klass, _wrap_ExDestinationIDSource_allocate);
  rb_define_method(cExDestinationIDSource.klass, "initialize", VALUEFUNC(_wrap_new_ExDestinationIDSource), -1);
  cExDestinationIDSource.mark = 0;
  cExDestinationIDSource.destroy = (void (*)(void *)) free_FIX_ExDestinationIDSource;
  cExDestinationIDSource.trackObjects = 0;
  
  cCollRespID.klass = rb_define_class_under(mQuickfix, "CollRespID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollRespID, (void *) &cCollRespID);
  rb_define_alloc_func(cCollRespID.klass, _wrap_CollRespID_allocate);
  rb_define_method(cCollRespID.klass, "initialize", VALUEFUNC(_wrap_new_CollRespID), -1);
  cCollRespID.mark = 0;
  cCollRespID.destroy = (void (*)(void *)) free_FIX_CollRespID;
  cCollRespID.trackObjects = 0;
  
  cSecurityListRequestType.klass = rb_define_class_under(mQuickfix, "SecurityListRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListRequestType, (void *) &cSecurityListRequestType);
  rb_define_alloc_func(cSecurityListRequestType.klass, _wrap_SecurityListRequestType_allocate);
  rb_define_method(cSecurityListRequestType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListRequestType), -1);
  cSecurityListRequestType.mark = 0;
  cSecurityListRequestType.destroy = (void (*)(void *)) free_FIX_SecurityListRequestType;
  cSecurityListRequestType.trackObjects = 0;
  
  cEncodedLegSecurityDesc.klass = rb_define_class_under(mQuickfix, "EncodedLegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegSecurityDesc, (void *) &cEncodedLegSecurityDesc);
  rb_define_alloc_func(cEncodedLegSecurityDesc.klass, _wrap_EncodedLegSecurityDesc_allocate);
  rb_define_method(cEncodedLegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegSecurityDesc), -1);
  cEncodedLegSecurityDesc.mark = 0;
  cEncodedLegSecurityDesc.destroy = (void (*)(void *)) free_FIX_EncodedLegSecurityDesc;
  cEncodedLegSecurityDesc.trackObjects = 0;
  
  cRelatedContextPartyRole.klass = rb_define_class_under(mQuickfix, "RelatedContextPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedContextPartyRole, (void *) &cRelatedContextPartyRole);
  rb_define_alloc_func(cRelatedContextPartyRole.klass, _wrap_RelatedContextPartyRole_allocate);
  rb_define_method(cRelatedContextPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_RelatedContextPartyRole), -1);
  cRelatedContextPartyRole.mark = 0;
  cRelatedContextPartyRole.destroy = (void (*)(void *)) free_FIX_RelatedContextPartyRole;
  cRelatedContextPartyRole.trackObjects = 0;
  
  cUnderlyingSettlementStatus.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlementStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlementStatus, (void *) &cUnderlyingSettlementStatus);
  rb_define_alloc_func(cUnderlyingSettlementStatus.klass, _wrap_UnderlyingSettlementStatus_allocate);
  rb_define_method(cUnderlyingSettlementStatus.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlementStatus), -1);
  cUnderlyingSettlementStatus.mark = 0;
  cUnderlyingSettlementStatus.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlementStatus;
  cUnderlyingSettlementStatus.trackObjects = 0;
  
  cSecurityAltID.klass = rb_define_class_under(mQuickfix, "SecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityAltID, (void *) &cSecurityAltID);
  rb_define_alloc_func(cSecurityAltID.klass, _wrap_SecurityAltID_allocate);
  rb_define_method(cSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityAltID), -1);
  cSecurityAltID.mark = 0;
  cSecurityAltID.destroy = (void (*)(void *)) free_FIX_SecurityAltID;
  cSecurityAltID.trackObjects = 0;
  
  cRegistRefID.klass = rb_define_class_under(mQuickfix, "RegistRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistRefID, (void *) &cRegistRefID);
  rb_define_alloc_func(cRegistRefID.klass, _wrap_RegistRefID_allocate);
  rb_define_method(cRegistRefID.klass, "initialize", VALUEFUNC(_wrap_new_RegistRefID), -1);
  cRegistRefID.mark = 0;
  cRegistRefID.destroy = (void (*)(void *)) free_FIX_RegistRefID;
  cRegistRefID.trackObjects = 0;
  
  cRelationshipRiskFlexibleIndicator.klass = rb_define_class_under(mQuickfix, "RelationshipRiskFlexibleIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskFlexibleIndicator, (void *) &cRelationshipRiskFlexibleIndicator);
  rb_define_alloc_func(cRelationshipRiskFlexibleIndicator.klass, _wrap_RelationshipRiskFlexibleIndicator_allocate);
  rb_define_method(cRelationshipRiskFlexibleIndicator.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskFlexibleIndicator), -1);
  cRelationshipRiskFlexibleIndicator.mark = 0;
  cRelationshipRiskFlexibleIndicator.destroy = (void (*)(void *)) free_FIX_RelationshipRiskFlexibleIndicator;
  cRelationshipRiskFlexibleIndicator.trackObjects = 0;
  
  cDerivativePriceQuoteMethod.klass = rb_define_class_under(mQuickfix, "DerivativePriceQuoteMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePriceQuoteMethod, (void *) &cDerivativePriceQuoteMethod);
  rb_define_alloc_func(cDerivativePriceQuoteMethod.klass, _wrap_DerivativePriceQuoteMethod_allocate);
  rb_define_method(cDerivativePriceQuoteMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePriceQuoteMethod), -1);
  cDerivativePriceQuoteMethod.mark = 0;
  cDerivativePriceQuoteMethod.destroy = (void (*)(void *)) free_FIX_DerivativePriceQuoteMethod;
  cDerivativePriceQuoteMethod.trackObjects = 0;
  
  cRelationshipRiskProductComplex.klass = rb_define_class_under(mQuickfix, "RelationshipRiskProductComplex", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskProductComplex, (void *) &cRelationshipRiskProductComplex);
  rb_define_alloc_func(cRelationshipRiskProductComplex.klass, _wrap_RelationshipRiskProductComplex_allocate);
  rb_define_method(cRelationshipRiskProductComplex.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskProductComplex), -1);
  cRelationshipRiskProductComplex.mark = 0;
  cRelationshipRiskProductComplex.destroy = (void (*)(void *)) free_FIX_RelationshipRiskProductComplex;
  cRelationshipRiskProductComplex.trackObjects = 0;
  
  cOrderDelay.klass = rb_define_class_under(mQuickfix, "OrderDelay", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderDelay, (void *) &cOrderDelay);
  rb_define_alloc_func(cOrderDelay.klass, _wrap_OrderDelay_allocate);
  rb_define_method(cOrderDelay.klass, "initialize", VALUEFUNC(_wrap_new_OrderDelay), -1);
  cOrderDelay.mark = 0;
  cOrderDelay.destroy = (void (*)(void *)) free_FIX_OrderDelay;
  cOrderDelay.trackObjects = 0;
  
  cNoNotAffectedOrders.klass = rb_define_class_under(mQuickfix, "NoNotAffectedOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNotAffectedOrders, (void *) &cNoNotAffectedOrders);
  rb_define_alloc_func(cNoNotAffectedOrders.klass, _wrap_NoNotAffectedOrders_allocate);
  rb_define_method(cNoNotAffectedOrders.klass, "initialize", VALUEFUNC(_wrap_new_NoNotAffectedOrders), -1);
  cNoNotAffectedOrders.mark = 0;
  cNoNotAffectedOrders.destroy = (void (*)(void *)) free_FIX_NoNotAffectedOrders;
  cNoNotAffectedOrders.trackObjects = 0;
  
  cNested3PartyID.klass = rb_define_class_under(mQuickfix, "Nested3PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartyID, (void *) &cNested3PartyID);
  rb_define_alloc_func(cNested3PartyID.klass, _wrap_Nested3PartyID_allocate);
  rb_define_method(cNested3PartyID.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartyID), -1);
  cNested3PartyID.mark = 0;
  cNested3PartyID.destroy = (void (*)(void *)) free_FIX_Nested3PartyID;
  cNested3PartyID.trackObjects = 0;
  
  cCollAsgnReason.klass = rb_define_class_under(mQuickfix, "CollAsgnReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnReason, (void *) &cCollAsgnReason);
  rb_define_alloc_func(cCollAsgnReason.klass, _wrap_CollAsgnReason_allocate);
  rb_define_method(cCollAsgnReason.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnReason), -1);
  cCollAsgnReason.mark = 0;
  cCollAsgnReason.destroy = (void (*)(void *)) free_FIX_CollAsgnReason;
  cCollAsgnReason.trackObjects = 0;
  
  cTotalVolumeTradedTime.klass = rb_define_class_under(mQuickfix, "TotalVolumeTradedTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalVolumeTradedTime, (void *) &cTotalVolumeTradedTime);
  rb_define_alloc_func(cTotalVolumeTradedTime.klass, _wrap_TotalVolumeTradedTime_allocate);
  rb_define_method(cTotalVolumeTradedTime.klass, "initialize", VALUEFUNC(_wrap_new_TotalVolumeTradedTime), -1);
  cTotalVolumeTradedTime.mark = 0;
  cTotalVolumeTradedTime.destroy = (void (*)(void *)) free_FIX_TotalVolumeTradedTime;
  cTotalVolumeTradedTime.trackObjects = 0;
  
  cSecurityExchange.klass = rb_define_class_under(mQuickfix, "SecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityExchange, (void *) &cSecurityExchange);
  rb_define_alloc_func(cSecurityExchange.klass, _wrap_SecurityExchange_allocate);
  rb_define_method(cSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_SecurityExchange), -1);
  cSecurityExchange.mark = 0;
  cSecurityExchange.destroy = (void (*)(void *)) free_FIX_SecurityExchange;
  cSecurityExchange.trackObjects = 0;
  
  cSettlPriceType.klass = rb_define_class_under(mQuickfix, "SettlPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPriceType, (void *) &cSettlPriceType);
  rb_define_alloc_func(cSettlPriceType.klass, _wrap_SettlPriceType_allocate);
  rb_define_method(cSettlPriceType.klass, "initialize", VALUEFUNC(_wrap_new_SettlPriceType), -1);
  cSettlPriceType.mark = 0;
  cSettlPriceType.destroy = (void (*)(void *)) free_FIX_SettlPriceType;
  cSettlPriceType.trackObjects = 0;
  
  cUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "UnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnitOfMeasureQty, (void *) &cUnitOfMeasureQty);
  rb_define_alloc_func(cUnitOfMeasureQty.klass, _wrap_UnitOfMeasureQty_allocate);
  rb_define_method(cUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_UnitOfMeasureQty), -1);
  cUnitOfMeasureQty.mark = 0;
  cUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_UnitOfMeasureQty;
  cUnitOfMeasureQty.trackObjects = 0;
  
  cUserRequestID.klass = rb_define_class_under(mQuickfix, "UserRequestID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserRequestID, (void *) &cUserRequestID);
  rb_define_alloc_func(cUserRequestID.klass, _wrap_UserRequestID_allocate);
  rb_define_method(cUserRequestID.klass, "initialize", VALUEFUNC(_wrap_new_UserRequestID), -1);
  cUserRequestID.mark = 0;
  cUserRequestID.destroy = (void (*)(void *)) free_FIX_UserRequestID;
  cUserRequestID.trackObjects = 0;
  
  cLastParPx.klass = rb_define_class_under(mQuickfix, "LastParPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastParPx, (void *) &cLastParPx);
  rb_define_alloc_func(cLastParPx.klass, _wrap_LastParPx_allocate);
  rb_define_method(cLastParPx.klass, "initialize", VALUEFUNC(_wrap_new_LastParPx), -1);
  cLastParPx.mark = 0;
  cLastParPx.destroy = (void (*)(void *)) free_FIX_LastParPx;
  cLastParPx.trackObjects = 0;
  
  cEndMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "EndMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndMaturityMonthYear, (void *) &cEndMaturityMonthYear);
  rb_define_alloc_func(cEndMaturityMonthYear.klass, _wrap_EndMaturityMonthYear_allocate);
  rb_define_method(cEndMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_EndMaturityMonthYear), -1);
  cEndMaturityMonthYear.mark = 0;
  cEndMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_EndMaturityMonthYear;
  cEndMaturityMonthYear.trackObjects = 0;
  
  cDealingCapacity.klass = rb_define_class_under(mQuickfix, "DealingCapacity", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DealingCapacity, (void *) &cDealingCapacity);
  rb_define_alloc_func(cDealingCapacity.klass, _wrap_DealingCapacity_allocate);
  rb_define_method(cDealingCapacity.klass, "initialize", VALUEFUNC(_wrap_new_DealingCapacity), -1);
  cDealingCapacity.mark = 0;
  cDealingCapacity.destroy = (void (*)(void *)) free_FIX_DealingCapacity;
  cDealingCapacity.trackObjects = 0;
  
  cPrevClosePx.klass = rb_define_class_under(mQuickfix, "PrevClosePx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PrevClosePx, (void *) &cPrevClosePx);
  rb_define_alloc_func(cPrevClosePx.klass, _wrap_PrevClosePx_allocate);
  rb_define_method(cPrevClosePx.klass, "initialize", VALUEFUNC(_wrap_new_PrevClosePx), -1);
  cPrevClosePx.mark = 0;
  cPrevClosePx.destroy = (void (*)(void *)) free_FIX_PrevClosePx;
  cPrevClosePx.trackObjects = 0;
  
  cTradeInputDevice.klass = rb_define_class_under(mQuickfix, "TradeInputDevice", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeInputDevice, (void *) &cTradeInputDevice);
  rb_define_alloc_func(cTradeInputDevice.klass, _wrap_TradeInputDevice_allocate);
  rb_define_method(cTradeInputDevice.klass, "initialize", VALUEFUNC(_wrap_new_TradeInputDevice), -1);
  cTradeInputDevice.mark = 0;
  cTradeInputDevice.destroy = (void (*)(void *)) free_FIX_TradeInputDevice;
  cTradeInputDevice.trackObjects = 0;
  
  cDayCumQty.klass = rb_define_class_under(mQuickfix, "DayCumQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayCumQty, (void *) &cDayCumQty);
  rb_define_alloc_func(cDayCumQty.klass, _wrap_DayCumQty_allocate);
  rb_define_method(cDayCumQty.klass, "initialize", VALUEFUNC(_wrap_new_DayCumQty), -1);
  cDayCumQty.mark = 0;
  cDayCumQty.destroy = (void (*)(void *)) free_FIX_DayCumQty;
  cDayCumQty.trackObjects = 0;
  
  cSecuritySettlAgentAcctNum.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentAcctNum", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentAcctNum, (void *) &cSecuritySettlAgentAcctNum);
  rb_define_alloc_func(cSecuritySettlAgentAcctNum.klass, _wrap_SecuritySettlAgentAcctNum_allocate);
  rb_define_method(cSecuritySettlAgentAcctNum.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentAcctNum), -1);
  cSecuritySettlAgentAcctNum.mark = 0;
  cSecuritySettlAgentAcctNum.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentAcctNum;
  cSecuritySettlAgentAcctNum.trackObjects = 0;
  
  cLegCurrency.klass = rb_define_class_under(mQuickfix, "LegCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCurrency, (void *) &cLegCurrency);
  rb_define_alloc_func(cLegCurrency.klass, _wrap_LegCurrency_allocate);
  rb_define_method(cLegCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegCurrency), -1);
  cLegCurrency.mark = 0;
  cLegCurrency.destroy = (void (*)(void *)) free_FIX_LegCurrency;
  cLegCurrency.trackObjects = 0;
  
  cEncryptedNewPassword.klass = rb_define_class_under(mQuickfix, "EncryptedNewPassword", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedNewPassword, (void *) &cEncryptedNewPassword);
  rb_define_alloc_func(cEncryptedNewPassword.klass, _wrap_EncryptedNewPassword_allocate);
  rb_define_method(cEncryptedNewPassword.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedNewPassword), -1);
  cEncryptedNewPassword.mark = 0;
  cEncryptedNewPassword.destroy = (void (*)(void *)) free_FIX_EncryptedNewPassword;
  cEncryptedNewPassword.trackObjects = 0;
  
  cDerivativeMinPriceIncrementAmount.klass = rb_define_class_under(mQuickfix, "DerivativeMinPriceIncrementAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMinPriceIncrementAmount, (void *) &cDerivativeMinPriceIncrementAmount);
  rb_define_alloc_func(cDerivativeMinPriceIncrementAmount.klass, _wrap_DerivativeMinPriceIncrementAmount_allocate);
  rb_define_method(cDerivativeMinPriceIncrementAmount.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMinPriceIncrementAmount), -1);
  cDerivativeMinPriceIncrementAmount.mark = 0;
  cDerivativeMinPriceIncrementAmount.destroy = (void (*)(void *)) free_FIX_DerivativeMinPriceIncrementAmount;
  cDerivativeMinPriceIncrementAmount.trackObjects = 0;
  
  cNoNested3PartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNested3PartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested3PartySubIDs, (void *) &cNoNested3PartySubIDs);
  rb_define_alloc_func(cNoNested3PartySubIDs.klass, _wrap_NoNested3PartySubIDs_allocate);
  rb_define_method(cNoNested3PartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested3PartySubIDs), -1);
  cNoNested3PartySubIDs.mark = 0;
  cNoNested3PartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNested3PartySubIDs;
  cNoNested3PartySubIDs.trackObjects = 0;
  
  cRefSubID.klass = rb_define_class_under(mQuickfix, "RefSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefSubID, (void *) &cRefSubID);
  rb_define_alloc_func(cRefSubID.klass, _wrap_RefSubID_allocate);
  rb_define_method(cRefSubID.klass, "initialize", VALUEFUNC(_wrap_new_RefSubID), -1);
  cRefSubID.mark = 0;
  cRefSubID.destroy = (void (*)(void *)) free_FIX_RefSubID;
  cRefSubID.trackObjects = 0;
  
  cSettlPartyRole.klass = rb_define_class_under(mQuickfix, "SettlPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartyRole, (void *) &cSettlPartyRole);
  rb_define_alloc_func(cSettlPartyRole.klass, _wrap_SettlPartyRole_allocate);
  rb_define_method(cSettlPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartyRole), -1);
  cSettlPartyRole.mark = 0;
  cSettlPartyRole.destroy = (void (*)(void *)) free_FIX_SettlPartyRole;
  cSettlPartyRole.trackObjects = 0;
  
  cCashDistribAgentName.klass = rb_define_class_under(mQuickfix, "CashDistribAgentName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentName, (void *) &cCashDistribAgentName);
  rb_define_alloc_func(cCashDistribAgentName.klass, _wrap_CashDistribAgentName_allocate);
  rb_define_method(cCashDistribAgentName.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentName), -1);
  cCashDistribAgentName.mark = 0;
  cCashDistribAgentName.destroy = (void (*)(void *)) free_FIX_CashDistribAgentName;
  cCashDistribAgentName.trackObjects = 0;
  
  cLegContractMultiplier.klass = rb_define_class_under(mQuickfix, "LegContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegContractMultiplier, (void *) &cLegContractMultiplier);
  rb_define_alloc_func(cLegContractMultiplier.klass, _wrap_LegContractMultiplier_allocate);
  rb_define_method(cLegContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_LegContractMultiplier), -1);
  cLegContractMultiplier.mark = 0;
  cLegContractMultiplier.destroy = (void (*)(void *)) free_FIX_LegContractMultiplier;
  cLegContractMultiplier.trackObjects = 0;
  
  cProgPeriodInterval.klass = rb_define_class_under(mQuickfix, "ProgPeriodInterval", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProgPeriodInterval, (void *) &cProgPeriodInterval);
  rb_define_alloc_func(cProgPeriodInterval.klass, _wrap_ProgPeriodInterval_allocate);
  rb_define_method(cProgPeriodInterval.klass, "initialize", VALUEFUNC(_wrap_new_ProgPeriodInterval), -1);
  cProgPeriodInterval.mark = 0;
  cProgPeriodInterval.destroy = (void (*)(void *)) free_FIX_ProgPeriodInterval;
  cProgPeriodInterval.trackObjects = 0;
  
  cLegSettlType.klass = rb_define_class_under(mQuickfix, "LegSettlType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlType, (void *) &cLegSettlType);
  rb_define_alloc_func(cLegSettlType.klass, _wrap_LegSettlType_allocate);
  rb_define_method(cLegSettlType.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlType), -1);
  cLegSettlType.mark = 0;
  cLegSettlType.destroy = (void (*)(void *)) free_FIX_LegSettlType;
  cLegSettlType.trackObjects = 0;
  
  cOnBehalfOfLocationID.klass = rb_define_class_under(mQuickfix, "OnBehalfOfLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfLocationID, (void *) &cOnBehalfOfLocationID);
  rb_define_alloc_func(cOnBehalfOfLocationID.klass, _wrap_OnBehalfOfLocationID_allocate);
  rb_define_method(cOnBehalfOfLocationID.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfLocationID), -1);
  cOnBehalfOfLocationID.mark = 0;
  cOnBehalfOfLocationID.destroy = (void (*)(void *)) free_FIX_OnBehalfOfLocationID;
  cOnBehalfOfLocationID.trackObjects = 0;
  
  cOnBehalfOfSubID.klass = rb_define_class_under(mQuickfix, "OnBehalfOfSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfSubID, (void *) &cOnBehalfOfSubID);
  rb_define_alloc_func(cOnBehalfOfSubID.klass, _wrap_OnBehalfOfSubID_allocate);
  rb_define_method(cOnBehalfOfSubID.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfSubID), -1);
  cOnBehalfOfSubID.mark = 0;
  cOnBehalfOfSubID.destroy = (void (*)(void *)) free_FIX_OnBehalfOfSubID;
  cOnBehalfOfSubID.trackObjects = 0;
  
  cRelationshipRiskLimitPlatform.klass = rb_define_class_under(mQuickfix, "RelationshipRiskLimitPlatform", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskLimitPlatform, (void *) &cRelationshipRiskLimitPlatform);
  rb_define_alloc_func(cRelationshipRiskLimitPlatform.klass, _wrap_RelationshipRiskLimitPlatform_allocate);
  rb_define_method(cRelationshipRiskLimitPlatform.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskLimitPlatform), -1);
  cRelationshipRiskLimitPlatform.mark = 0;
  cRelationshipRiskLimitPlatform.destroy = (void (*)(void *)) free_FIX_RelationshipRiskLimitPlatform;
  cRelationshipRiskLimitPlatform.trackObjects = 0;
  
  cRelatedPartySubID.klass = rb_define_class_under(mQuickfix, "RelatedPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartySubID, (void *) &cRelatedPartySubID);
  rb_define_alloc_func(cRelatedPartySubID.klass, _wrap_RelatedPartySubID_allocate);
  rb_define_method(cRelatedPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartySubID), -1);
  cRelatedPartySubID.mark = 0;
  cRelatedPartySubID.destroy = (void (*)(void *)) free_FIX_RelatedPartySubID;
  cRelatedPartySubID.trackObjects = 0;
  
  cComplexEventEndTime.klass = rb_define_class_under(mQuickfix, "ComplexEventEndTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventEndTime, (void *) &cComplexEventEndTime);
  rb_define_alloc_func(cComplexEventEndTime.klass, _wrap_ComplexEventEndTime_allocate);
  rb_define_method(cComplexEventEndTime.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventEndTime), -1);
  cComplexEventEndTime.mark = 0;
  cComplexEventEndTime.destroy = (void (*)(void *)) free_FIX_ComplexEventEndTime;
  cComplexEventEndTime.trackObjects = 0;
  
  cRateSourceType.klass = rb_define_class_under(mQuickfix, "RateSourceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RateSourceType, (void *) &cRateSourceType);
  rb_define_alloc_func(cRateSourceType.klass, _wrap_RateSourceType_allocate);
  rb_define_method(cRateSourceType.klass, "initialize", VALUEFUNC(_wrap_new_RateSourceType), -1);
  cRateSourceType.mark = 0;
  cRateSourceType.destroy = (void (*)(void *)) free_FIX_RateSourceType;
  cRateSourceType.trackObjects = 0;
  
  cDerivativeStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "DerivativeStateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStateOrProvinceOfIssue, (void *) &cDerivativeStateOrProvinceOfIssue);
  rb_define_alloc_func(cDerivativeStateOrProvinceOfIssue.klass, _wrap_DerivativeStateOrProvinceOfIssue_allocate);
  rb_define_method(cDerivativeStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStateOrProvinceOfIssue), -1);
  cDerivativeStateOrProvinceOfIssue.mark = 0;
  cDerivativeStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_DerivativeStateOrProvinceOfIssue;
  cDerivativeStateOrProvinceOfIssue.trackObjects = 0;
  
  cTradeLegRefID.klass = rb_define_class_under(mQuickfix, "TradeLegRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeLegRefID, (void *) &cTradeLegRefID);
  rb_define_alloc_func(cTradeLegRefID.klass, _wrap_TradeLegRefID_allocate);
  rb_define_method(cTradeLegRefID.klass, "initialize", VALUEFUNC(_wrap_new_TradeLegRefID), -1);
  cTradeLegRefID.mark = 0;
  cTradeLegRefID.destroy = (void (*)(void *)) free_FIX_TradeLegRefID;
  cTradeLegRefID.trackObjects = 0;
  
  cRelSymTransactTime.klass = rb_define_class_under(mQuickfix, "RelSymTransactTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelSymTransactTime, (void *) &cRelSymTransactTime);
  rb_define_alloc_func(cRelSymTransactTime.klass, _wrap_RelSymTransactTime_allocate);
  rb_define_method(cRelSymTransactTime.klass, "initialize", VALUEFUNC(_wrap_new_RelSymTransactTime), -1);
  cRelSymTransactTime.mark = 0;
  cRelSymTransactTime.destroy = (void (*)(void *)) free_FIX_RelSymTransactTime;
  cRelSymTransactTime.trackObjects = 0;
  
  cNoComplexEventTimes.klass = rb_define_class_under(mQuickfix, "NoComplexEventTimes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoComplexEventTimes, (void *) &cNoComplexEventTimes);
  rb_define_alloc_func(cNoComplexEventTimes.klass, _wrap_NoComplexEventTimes_allocate);
  rb_define_method(cNoComplexEventTimes.klass, "initialize", VALUEFUNC(_wrap_new_NoComplexEventTimes), -1);
  cNoComplexEventTimes.mark = 0;
  cNoComplexEventTimes.destroy = (void (*)(void *)) free_FIX_NoComplexEventTimes;
  cNoComplexEventTimes.trackObjects = 0;
  
  cLegCalculatedCcyLastQty.klass = rb_define_class_under(mQuickfix, "LegCalculatedCcyLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCalculatedCcyLastQty, (void *) &cLegCalculatedCcyLastQty);
  rb_define_alloc_func(cLegCalculatedCcyLastQty.klass, _wrap_LegCalculatedCcyLastQty_allocate);
  rb_define_method(cLegCalculatedCcyLastQty.klass, "initialize", VALUEFUNC(_wrap_new_LegCalculatedCcyLastQty), -1);
  cLegCalculatedCcyLastQty.mark = 0;
  cLegCalculatedCcyLastQty.destroy = (void (*)(void *)) free_FIX_LegCalculatedCcyLastQty;
  cLegCalculatedCcyLastQty.trackObjects = 0;
  
  cNested3PartyIDSource.klass = rb_define_class_under(mQuickfix, "Nested3PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartyIDSource, (void *) &cNested3PartyIDSource);
  rb_define_alloc_func(cNested3PartyIDSource.klass, _wrap_Nested3PartyIDSource_allocate);
  rb_define_method(cNested3PartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartyIDSource), -1);
  cNested3PartyIDSource.mark = 0;
  cNested3PartyIDSource.destroy = (void (*)(void *)) free_FIX_Nested3PartyIDSource;
  cNested3PartyIDSource.trackObjects = 0;
  
  cDatedDate.klass = rb_define_class_under(mQuickfix, "DatedDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DatedDate, (void *) &cDatedDate);
  rb_define_alloc_func(cDatedDate.klass, _wrap_DatedDate_allocate);
  rb_define_method(cDatedDate.klass, "initialize", VALUEFUNC(_wrap_new_DatedDate), -1);
  cDatedDate.mark = 0;
  cDatedDate.destroy = (void (*)(void *)) free_FIX_DatedDate;
  cDatedDate.trackObjects = 0;
  
  cSettlInstID.klass = rb_define_class_under(mQuickfix, "SettlInstID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstID, (void *) &cSettlInstID);
  rb_define_alloc_func(cSettlInstID.klass, _wrap_SettlInstID_allocate);
  rb_define_method(cSettlInstID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstID), -1);
  cSettlInstID.mark = 0;
  cSettlInstID.destroy = (void (*)(void *)) free_FIX_SettlInstID;
  cSettlInstID.trackObjects = 0;
  
  cOpenInterest.klass = rb_define_class_under(mQuickfix, "OpenInterest", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenInterest, (void *) &cOpenInterest);
  rb_define_alloc_func(cOpenInterest.klass, _wrap_OpenInterest_allocate);
  rb_define_method(cOpenInterest.klass, "initialize", VALUEFUNC(_wrap_new_OpenInterest), -1);
  cOpenInterest.mark = 0;
  cOpenInterest.destroy = (void (*)(void *)) free_FIX_OpenInterest;
  cOpenInterest.trackObjects = 0;
  
  cUnderlyingContractMultiplier.klass = rb_define_class_under(mQuickfix, "UnderlyingContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingContractMultiplier, (void *) &cUnderlyingContractMultiplier);
  rb_define_alloc_func(cUnderlyingContractMultiplier.klass, _wrap_UnderlyingContractMultiplier_allocate);
  rb_define_method(cUnderlyingContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingContractMultiplier), -1);
  cUnderlyingContractMultiplier.mark = 0;
  cUnderlyingContractMultiplier.destroy = (void (*)(void *)) free_FIX_UnderlyingContractMultiplier;
  cUnderlyingContractMultiplier.trackObjects = 0;
  
  cTotQuoteEntries.klass = rb_define_class_under(mQuickfix, "TotQuoteEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotQuoteEntries, (void *) &cTotQuoteEntries);
  rb_define_alloc_func(cTotQuoteEntries.klass, _wrap_TotQuoteEntries_allocate);
  rb_define_method(cTotQuoteEntries.klass, "initialize", VALUEFUNC(_wrap_new_TotQuoteEntries), -1);
  cTotQuoteEntries.mark = 0;
  cTotQuoteEntries.destroy = (void (*)(void *)) free_FIX_TotQuoteEntries;
  cTotQuoteEntries.trackObjects = 0;
  
  cPartyAltSubID.klass = rb_define_class_under(mQuickfix, "PartyAltSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyAltSubID, (void *) &cPartyAltSubID);
  rb_define_alloc_func(cPartyAltSubID.klass, _wrap_PartyAltSubID_allocate);
  rb_define_method(cPartyAltSubID.klass, "initialize", VALUEFUNC(_wrap_new_PartyAltSubID), -1);
  cPartyAltSubID.mark = 0;
  cPartyAltSubID.destroy = (void (*)(void *)) free_FIX_PartyAltSubID;
  cPartyAltSubID.trackObjects = 0;
  
  cTotNoCxldQuotes.klass = rb_define_class_under(mQuickfix, "TotNoCxldQuotes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoCxldQuotes, (void *) &cTotNoCxldQuotes);
  rb_define_alloc_func(cTotNoCxldQuotes.klass, _wrap_TotNoCxldQuotes_allocate);
  rb_define_method(cTotNoCxldQuotes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoCxldQuotes), -1);
  cTotNoCxldQuotes.mark = 0;
  cTotNoCxldQuotes.destroy = (void (*)(void *)) free_FIX_TotNoCxldQuotes;
  cTotNoCxldQuotes.trackObjects = 0;
  
  cAggregatedBook.klass = rb_define_class_under(mQuickfix, "AggregatedBook", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AggregatedBook, (void *) &cAggregatedBook);
  rb_define_alloc_func(cAggregatedBook.klass, _wrap_AggregatedBook_allocate);
  rb_define_method(cAggregatedBook.klass, "initialize", VALUEFUNC(_wrap_new_AggregatedBook), -1);
  cAggregatedBook.mark = 0;
  cAggregatedBook.destroy = (void (*)(void *)) free_FIX_AggregatedBook;
  cAggregatedBook.trackObjects = 0;
  
  cPaymentRef.klass = rb_define_class_under(mQuickfix, "PaymentRef", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentRef, (void *) &cPaymentRef);
  rb_define_alloc_func(cPaymentRef.klass, _wrap_PaymentRef_allocate);
  rb_define_method(cPaymentRef.klass, "initialize", VALUEFUNC(_wrap_new_PaymentRef), -1);
  cPaymentRef.mark = 0;
  cPaymentRef.destroy = (void (*)(void *)) free_FIX_PaymentRef;
  cPaymentRef.trackObjects = 0;
  
  cPaymentDate.klass = rb_define_class_under(mQuickfix, "PaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentDate, (void *) &cPaymentDate);
  rb_define_alloc_func(cPaymentDate.klass, _wrap_PaymentDate_allocate);
  rb_define_method(cPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_PaymentDate), -1);
  cPaymentDate.mark = 0;
  cPaymentDate.destroy = (void (*)(void *)) free_FIX_PaymentDate;
  cPaymentDate.trackObjects = 0;
  
  cOrderPercent.klass = rb_define_class_under(mQuickfix, "OrderPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderPercent, (void *) &cOrderPercent);
  rb_define_alloc_func(cOrderPercent.klass, _wrap_OrderPercent_allocate);
  rb_define_method(cOrderPercent.klass, "initialize", VALUEFUNC(_wrap_new_OrderPercent), -1);
  cOrderPercent.mark = 0;
  cOrderPercent.destroy = (void (*)(void *)) free_FIX_OrderPercent;
  cOrderPercent.trackObjects = 0;
  
  cPosQtyStatus.klass = rb_define_class_under(mQuickfix, "PosQtyStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosQtyStatus, (void *) &cPosQtyStatus);
  rb_define_alloc_func(cPosQtyStatus.klass, _wrap_PosQtyStatus_allocate);
  rb_define_method(cPosQtyStatus.klass, "initialize", VALUEFUNC(_wrap_new_PosQtyStatus), -1);
  cPosQtyStatus.mark = 0;
  cPosQtyStatus.destroy = (void (*)(void *)) free_FIX_PosQtyStatus;
  cPosQtyStatus.trackObjects = 0;
  
  cRiskRestructuringType.klass = rb_define_class_under(mQuickfix, "RiskRestructuringType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskRestructuringType, (void *) &cRiskRestructuringType);
  rb_define_alloc_func(cRiskRestructuringType.klass, _wrap_RiskRestructuringType_allocate);
  rb_define_method(cRiskRestructuringType.klass, "initialize", VALUEFUNC(_wrap_new_RiskRestructuringType), -1);
  cRiskRestructuringType.mark = 0;
  cRiskRestructuringType.destroy = (void (*)(void *)) free_FIX_RiskRestructuringType;
  cRiskRestructuringType.trackObjects = 0;
  
  cNoNested4PartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNested4PartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested4PartySubIDs, (void *) &cNoNested4PartySubIDs);
  rb_define_alloc_func(cNoNested4PartySubIDs.klass, _wrap_NoNested4PartySubIDs_allocate);
  rb_define_method(cNoNested4PartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested4PartySubIDs), -1);
  cNoNested4PartySubIDs.mark = 0;
  cNoNested4PartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNested4PartySubIDs;
  cNoNested4PartySubIDs.trackObjects = 0;
  
  cPrivateQuote.klass = rb_define_class_under(mQuickfix, "PrivateQuote", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PrivateQuote, (void *) &cPrivateQuote);
  rb_define_alloc_func(cPrivateQuote.klass, _wrap_PrivateQuote_allocate);
  rb_define_method(cPrivateQuote.klass, "initialize", VALUEFUNC(_wrap_new_PrivateQuote), -1);
  cPrivateQuote.mark = 0;
  cPrivateQuote.destroy = (void (*)(void *)) free_FIX_PrivateQuote;
  cPrivateQuote.trackObjects = 0;
  
  cSecondaryTradeID.klass = rb_define_class_under(mQuickfix, "SecondaryTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradeID, (void *) &cSecondaryTradeID);
  rb_define_alloc_func(cSecondaryTradeID.klass, _wrap_SecondaryTradeID_allocate);
  rb_define_method(cSecondaryTradeID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradeID), -1);
  cSecondaryTradeID.mark = 0;
  cSecondaryTradeID.destroy = (void (*)(void *)) free_FIX_SecondaryTradeID;
  cSecondaryTradeID.trackObjects = 0;
  
  cSecuritySettlAgentContactPhone.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentContactPhone", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentContactPhone, (void *) &cSecuritySettlAgentContactPhone);
  rb_define_alloc_func(cSecuritySettlAgentContactPhone.klass, _wrap_SecuritySettlAgentContactPhone_allocate);
  rb_define_method(cSecuritySettlAgentContactPhone.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentContactPhone), -1);
  cSecuritySettlAgentContactPhone.mark = 0;
  cSecuritySettlAgentContactPhone.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentContactPhone;
  cSecuritySettlAgentContactPhone.trackObjects = 0;
  
  cEncodedMktSegmDescLen.klass = rb_define_class_under(mQuickfix, "EncodedMktSegmDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedMktSegmDescLen, (void *) &cEncodedMktSegmDescLen);
  rb_define_alloc_func(cEncodedMktSegmDescLen.klass, _wrap_EncodedMktSegmDescLen_allocate);
  rb_define_method(cEncodedMktSegmDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedMktSegmDescLen), -1);
  cEncodedMktSegmDescLen.mark = 0;
  cEncodedMktSegmDescLen.destroy = (void (*)(void *)) free_FIX_EncodedMktSegmDescLen;
  cEncodedMktSegmDescLen.trackObjects = 0;
  
  cSideCurrency.klass = rb_define_class_under(mQuickfix, "SideCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideCurrency, (void *) &cSideCurrency);
  rb_define_alloc_func(cSideCurrency.klass, _wrap_SideCurrency_allocate);
  rb_define_method(cSideCurrency.klass, "initialize", VALUEFUNC(_wrap_new_SideCurrency), -1);
  cSideCurrency.mark = 0;
  cSideCurrency.destroy = (void (*)(void *)) free_FIX_SideCurrency;
  cSideCurrency.trackObjects = 0;
  
  cLegQty.klass = rb_define_class_under(mQuickfix, "LegQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegQty, (void *) &cLegQty);
  rb_define_alloc_func(cLegQty.klass, _wrap_LegQty_allocate);
  rb_define_method(cLegQty.klass, "initialize", VALUEFUNC(_wrap_new_LegQty), -1);
  cLegQty.mark = 0;
  cLegQty.destroy = (void (*)(void *)) free_FIX_LegQty;
  cLegQty.trackObjects = 0;
  
  cMsgType.klass = rb_define_class_under(mQuickfix, "MsgType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MsgType, (void *) &cMsgType);
  rb_define_alloc_func(cMsgType.klass, _wrap_MsgType_allocate);
  rb_define_method(cMsgType.klass, "initialize", VALUEFUNC(_wrap_new_MsgType), -1);
  cMsgType.mark = 0;
  cMsgType.destroy = (void (*)(void *)) free_FIX_MsgType;
  cMsgType.trackObjects = 0;
  
  cNoTradingSessions.klass = rb_define_class_under(mQuickfix, "NoTradingSessions", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTradingSessions, (void *) &cNoTradingSessions);
  rb_define_alloc_func(cNoTradingSessions.klass, _wrap_NoTradingSessions_allocate);
  rb_define_method(cNoTradingSessions.klass, "initialize", VALUEFUNC(_wrap_new_NoTradingSessions), -1);
  cNoTradingSessions.mark = 0;
  cNoTradingSessions.destroy = (void (*)(void *)) free_FIX_NoTradingSessions;
  cNoTradingSessions.trackObjects = 0;
  
  cIOIid.klass = rb_define_class_under(mQuickfix, "IOIid", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIid, (void *) &cIOIid);
  rb_define_alloc_func(cIOIid.klass, _wrap_IOIid_allocate);
  rb_define_method(cIOIid.klass, "initialize", VALUEFUNC(_wrap_new_IOIid), -1);
  cIOIid.mark = 0;
  cIOIid.destroy = (void (*)(void *)) free_FIX_IOIid;
  cIOIid.trackObjects = 0;
  
  cMultiLegReportingType.klass = rb_define_class_under(mQuickfix, "MultiLegReportingType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultiLegReportingType, (void *) &cMultiLegReportingType);
  rb_define_alloc_func(cMultiLegReportingType.klass, _wrap_MultiLegReportingType_allocate);
  rb_define_method(cMultiLegReportingType.klass, "initialize", VALUEFUNC(_wrap_new_MultiLegReportingType), -1);
  cMultiLegReportingType.mark = 0;
  cMultiLegReportingType.destroy = (void (*)(void *)) free_FIX_MultiLegReportingType;
  cMultiLegReportingType.trackObjects = 0;
  
  cIDSource.klass = rb_define_class_under(mQuickfix, "IDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IDSource, (void *) &cIDSource);
  rb_define_alloc_func(cIDSource.klass, _wrap_IDSource_allocate);
  rb_define_method(cIDSource.klass, "initialize", VALUEFUNC(_wrap_new_IDSource), -1);
  cIDSource.mark = 0;
  cIDSource.destroy = (void (*)(void *)) free_FIX_IDSource;
  cIDSource.trackObjects = 0;
  
  cLegStipulationType.klass = rb_define_class_under(mQuickfix, "LegStipulationType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStipulationType, (void *) &cLegStipulationType);
  rb_define_alloc_func(cLegStipulationType.klass, _wrap_LegStipulationType_allocate);
  rb_define_method(cLegStipulationType.klass, "initialize", VALUEFUNC(_wrap_new_LegStipulationType), -1);
  cLegStipulationType.mark = 0;
  cLegStipulationType.destroy = (void (*)(void *)) free_FIX_LegStipulationType;
  cLegStipulationType.trackObjects = 0;
  
  cDerivativeContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "DerivativeContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeContractMultiplierUnit, (void *) &cDerivativeContractMultiplierUnit);
  rb_define_alloc_func(cDerivativeContractMultiplierUnit.klass, _wrap_DerivativeContractMultiplierUnit_allocate);
  rb_define_method(cDerivativeContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeContractMultiplierUnit), -1);
  cDerivativeContractMultiplierUnit.mark = 0;
  cDerivativeContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_DerivativeContractMultiplierUnit;
  cDerivativeContractMultiplierUnit.trackObjects = 0;
  
  cMarketSegmentID.klass = rb_define_class_under(mQuickfix, "MarketSegmentID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketSegmentID, (void *) &cMarketSegmentID);
  rb_define_alloc_func(cMarketSegmentID.klass, _wrap_MarketSegmentID_allocate);
  rb_define_method(cMarketSegmentID.klass, "initialize", VALUEFUNC(_wrap_new_MarketSegmentID), -1);
  cMarketSegmentID.mark = 0;
  cMarketSegmentID.destroy = (void (*)(void *)) free_FIX_MarketSegmentID;
  cMarketSegmentID.trackObjects = 0;
  
  cOrdStatus.klass = rb_define_class_under(mQuickfix, "OrdStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdStatus, (void *) &cOrdStatus);
  rb_define_alloc_func(cOrdStatus.klass, _wrap_OrdStatus_allocate);
  rb_define_method(cOrdStatus.klass, "initialize", VALUEFUNC(_wrap_new_OrdStatus), -1);
  cOrdStatus.mark = 0;
  cOrdStatus.destroy = (void (*)(void *)) free_FIX_OrdStatus;
  cOrdStatus.trackObjects = 0;
  
  cMaturityDate.klass = rb_define_class_under(mQuickfix, "MaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityDate, (void *) &cMaturityDate);
  rb_define_alloc_func(cMaturityDate.klass, _wrap_MaturityDate_allocate);
  rb_define_method(cMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_MaturityDate), -1);
  cMaturityDate.mark = 0;
  cMaturityDate.destroy = (void (*)(void *)) free_FIX_MaturityDate;
  cMaturityDate.trackObjects = 0;
  
  cApplTotalMessageCount.klass = rb_define_class_under(mQuickfix, "ApplTotalMessageCount", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplTotalMessageCount, (void *) &cApplTotalMessageCount);
  rb_define_alloc_func(cApplTotalMessageCount.klass, _wrap_ApplTotalMessageCount_allocate);
  rb_define_method(cApplTotalMessageCount.klass, "initialize", VALUEFUNC(_wrap_new_ApplTotalMessageCount), -1);
  cApplTotalMessageCount.mark = 0;
  cApplTotalMessageCount.destroy = (void (*)(void *)) free_FIX_ApplTotalMessageCount;
  cApplTotalMessageCount.trackObjects = 0;
  
  cInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "InstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartySubID, (void *) &cInstrumentPartySubID);
  rb_define_alloc_func(cInstrumentPartySubID.klass, _wrap_InstrumentPartySubID_allocate);
  rb_define_method(cInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartySubID), -1);
  cInstrumentPartySubID.mark = 0;
  cInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_InstrumentPartySubID;
  cInstrumentPartySubID.trackObjects = 0;
  
  cCustomerOrFirm.klass = rb_define_class_under(mQuickfix, "CustomerOrFirm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustomerOrFirm, (void *) &cCustomerOrFirm);
  rb_define_alloc_func(cCustomerOrFirm.klass, _wrap_CustomerOrFirm_allocate);
  rb_define_method(cCustomerOrFirm.klass, "initialize", VALUEFUNC(_wrap_new_CustomerOrFirm), -1);
  cCustomerOrFirm.mark = 0;
  cCustomerOrFirm.destroy = (void (*)(void *)) free_FIX_CustomerOrFirm;
  cCustomerOrFirm.trackObjects = 0;
  
  cAdjustmentType.klass = rb_define_class_under(mQuickfix, "AdjustmentType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdjustmentType, (void *) &cAdjustmentType);
  rb_define_alloc_func(cAdjustmentType.klass, _wrap_AdjustmentType_allocate);
  rb_define_method(cAdjustmentType.klass, "initialize", VALUEFUNC(_wrap_new_AdjustmentType), -1);
  cAdjustmentType.mark = 0;
  cAdjustmentType.destroy = (void (*)(void *)) free_FIX_AdjustmentType;
  cAdjustmentType.trackObjects = 0;
  
  cNoPartyAltSubIDs.klass = rb_define_class_under(mQuickfix, "NoPartyAltSubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartyAltSubIDs, (void *) &cNoPartyAltSubIDs);
  rb_define_alloc_func(cNoPartyAltSubIDs.klass, _wrap_NoPartyAltSubIDs_allocate);
  rb_define_method(cNoPartyAltSubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoPartyAltSubIDs), -1);
  cNoPartyAltSubIDs.mark = 0;
  cNoPartyAltSubIDs.destroy = (void (*)(void *)) free_FIX_NoPartyAltSubIDs;
  cNoPartyAltSubIDs.trackObjects = 0;
  
  cUnderlyingInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyID, (void *) &cUnderlyingInstrumentPartyID);
  rb_define_alloc_func(cUnderlyingInstrumentPartyID.klass, _wrap_UnderlyingInstrumentPartyID_allocate);
  rb_define_method(cUnderlyingInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartyID), -1);
  cUnderlyingInstrumentPartyID.mark = 0;
  cUnderlyingInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartyID;
  cUnderlyingInstrumentPartyID.trackObjects = 0;
  
  cAsOfIndicator.klass = rb_define_class_under(mQuickfix, "AsOfIndicator", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AsOfIndicator, (void *) &cAsOfIndicator);
  rb_define_alloc_func(cAsOfIndicator.klass, _wrap_AsOfIndicator_allocate);
  rb_define_method(cAsOfIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AsOfIndicator), -1);
  cAsOfIndicator.mark = 0;
  cAsOfIndicator.destroy = (void (*)(void *)) free_FIX_AsOfIndicator;
  cAsOfIndicator.trackObjects = 0;
  
  cQuoteStatusReqID.klass = rb_define_class_under(mQuickfix, "QuoteStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteStatusReqID, (void *) &cQuoteStatusReqID);
  rb_define_alloc_func(cQuoteStatusReqID.klass, _wrap_QuoteStatusReqID_allocate);
  rb_define_method(cQuoteStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteStatusReqID), -1);
  cQuoteStatusReqID.mark = 0;
  cQuoteStatusReqID.destroy = (void (*)(void *)) free_FIX_QuoteStatusReqID;
  cQuoteStatusReqID.trackObjects = 0;
  
  cLegPositionEffect.klass = rb_define_class_under(mQuickfix, "LegPositionEffect", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPositionEffect, (void *) &cLegPositionEffect);
  rb_define_alloc_func(cLegPositionEffect.klass, _wrap_LegPositionEffect_allocate);
  rb_define_method(cLegPositionEffect.klass, "initialize", VALUEFUNC(_wrap_new_LegPositionEffect), -1);
  cLegPositionEffect.mark = 0;
  cLegPositionEffect.destroy = (void (*)(void *)) free_FIX_LegPositionEffect;
  cLegPositionEffect.trackObjects = 0;
  
  cMDEntryPx.klass = rb_define_class_under(mQuickfix, "MDEntryPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryPx, (void *) &cMDEntryPx);
  rb_define_alloc_func(cMDEntryPx.klass, _wrap_MDEntryPx_allocate);
  rb_define_method(cMDEntryPx.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryPx), -1);
  cMDEntryPx.mark = 0;
  cMDEntryPx.destroy = (void (*)(void *)) free_FIX_MDEntryPx;
  cMDEntryPx.trackObjects = 0;
  
  cMassActionScope.klass = rb_define_class_under(mQuickfix, "MassActionScope", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionScope, (void *) &cMassActionScope);
  rb_define_alloc_func(cMassActionScope.klass, _wrap_MassActionScope_allocate);
  rb_define_method(cMassActionScope.klass, "initialize", VALUEFUNC(_wrap_new_MassActionScope), -1);
  cMassActionScope.mark = 0;
  cMassActionScope.destroy = (void (*)(void *)) free_FIX_MassActionScope;
  cMassActionScope.trackObjects = 0;
  
  cReportedPxDiff.klass = rb_define_class_under(mQuickfix, "ReportedPxDiff", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReportedPxDiff, (void *) &cReportedPxDiff);
  rb_define_alloc_func(cReportedPxDiff.klass, _wrap_ReportedPxDiff_allocate);
  rb_define_method(cReportedPxDiff.klass, "initialize", VALUEFUNC(_wrap_new_ReportedPxDiff), -1);
  cReportedPxDiff.mark = 0;
  cReportedPxDiff.destroy = (void (*)(void *)) free_FIX_ReportedPxDiff;
  cReportedPxDiff.trackObjects = 0;
  
  cUnderlyingSettlementDate.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlementDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlementDate, (void *) &cUnderlyingSettlementDate);
  rb_define_alloc_func(cUnderlyingSettlementDate.klass, _wrap_UnderlyingSettlementDate_allocate);
  rb_define_method(cUnderlyingSettlementDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlementDate), -1);
  cUnderlyingSettlementDate.mark = 0;
  cUnderlyingSettlementDate.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlementDate;
  cUnderlyingSettlementDate.trackObjects = 0;
  
  cNoNestedPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNestedPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNestedPartySubIDs, (void *) &cNoNestedPartySubIDs);
  rb_define_alloc_func(cNoNestedPartySubIDs.klass, _wrap_NoNestedPartySubIDs_allocate);
  rb_define_method(cNoNestedPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNestedPartySubIDs), -1);
  cNoNestedPartySubIDs.mark = 0;
  cNoNestedPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNestedPartySubIDs;
  cNoNestedPartySubIDs.trackObjects = 0;
  
  cAllocReportRefID.klass = rb_define_class_under(mQuickfix, "AllocReportRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocReportRefID, (void *) &cAllocReportRefID);
  rb_define_alloc_func(cAllocReportRefID.klass, _wrap_AllocReportRefID_allocate);
  rb_define_method(cAllocReportRefID.klass, "initialize", VALUEFUNC(_wrap_new_AllocReportRefID), -1);
  cAllocReportRefID.mark = 0;
  cAllocReportRefID.destroy = (void (*)(void *)) free_FIX_AllocReportRefID;
  cAllocReportRefID.trackObjects = 0;
  
  cConcession.klass = rb_define_class_under(mQuickfix, "Concession", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Concession, (void *) &cConcession);
  rb_define_alloc_func(cConcession.klass, _wrap_Concession_allocate);
  rb_define_method(cConcession.klass, "initialize", VALUEFUNC(_wrap_new_Concession), -1);
  cConcession.mark = 0;
  cConcession.destroy = (void (*)(void *)) free_FIX_Concession;
  cConcession.trackObjects = 0;
  
  cEncodedSecurityDesc.klass = rb_define_class_under(mQuickfix, "EncodedSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityDesc, (void *) &cEncodedSecurityDesc);
  rb_define_alloc_func(cEncodedSecurityDesc.klass, _wrap_EncodedSecurityDesc_allocate);
  rb_define_method(cEncodedSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityDesc), -1);
  cEncodedSecurityDesc.mark = 0;
  cEncodedSecurityDesc.destroy = (void (*)(void *)) free_FIX_EncodedSecurityDesc;
  cEncodedSecurityDesc.trackObjects = 0;
  
  cExecRefID.klass = rb_define_class_under(mQuickfix, "ExecRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecRefID, (void *) &cExecRefID);
  rb_define_alloc_func(cExecRefID.klass, _wrap_ExecRefID_allocate);
  rb_define_method(cExecRefID.klass, "initialize", VALUEFUNC(_wrap_new_ExecRefID), -1);
  cExecRefID.mark = 0;
  cExecRefID.destroy = (void (*)(void *)) free_FIX_ExecRefID;
  cExecRefID.trackObjects = 0;
  
  cVenueType.klass = rb_define_class_under(mQuickfix, "VenueType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__VenueType, (void *) &cVenueType);
  rb_define_alloc_func(cVenueType.klass, _wrap_VenueType_allocate);
  rb_define_method(cVenueType.klass, "initialize", VALUEFUNC(_wrap_new_VenueType), -1);
  cVenueType.mark = 0;
  cVenueType.destroy = (void (*)(void *)) free_FIX_VenueType;
  cVenueType.trackObjects = 0;
  
  cMassActionType.klass = rb_define_class_under(mQuickfix, "MassActionType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionType, (void *) &cMassActionType);
  rb_define_alloc_func(cMassActionType.klass, _wrap_MassActionType_allocate);
  rb_define_method(cMassActionType.klass, "initialize", VALUEFUNC(_wrap_new_MassActionType), -1);
  cMassActionType.mark = 0;
  cMassActionType.destroy = (void (*)(void *)) free_FIX_MassActionType;
  cMassActionType.trackObjects = 0;
  
  cPosMaintResult.klass = rb_define_class_under(mQuickfix, "PosMaintResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintResult, (void *) &cPosMaintResult);
  rb_define_alloc_func(cPosMaintResult.klass, _wrap_PosMaintResult_allocate);
  rb_define_method(cPosMaintResult.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintResult), -1);
  cPosMaintResult.mark = 0;
  cPosMaintResult.destroy = (void (*)(void *)) free_FIX_PosMaintResult;
  cPosMaintResult.trackObjects = 0;
  
  cIOIShares.klass = rb_define_class_under(mQuickfix, "IOIShares", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIShares, (void *) &cIOIShares);
  rb_define_alloc_func(cIOIShares.klass, _wrap_IOIShares_allocate);
  rb_define_method(cIOIShares.klass, "initialize", VALUEFUNC(_wrap_new_IOIShares), -1);
  cIOIShares.mark = 0;
  cIOIShares.destroy = (void (*)(void *)) free_FIX_IOIShares;
  cIOIShares.trackObjects = 0;
  
  cBenchmarkSecurityID.klass = rb_define_class_under(mQuickfix, "BenchmarkSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkSecurityID, (void *) &cBenchmarkSecurityID);
  rb_define_alloc_func(cBenchmarkSecurityID.klass, _wrap_BenchmarkSecurityID_allocate);
  rb_define_method(cBenchmarkSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkSecurityID), -1);
  cBenchmarkSecurityID.mark = 0;
  cBenchmarkSecurityID.destroy = (void (*)(void *)) free_FIX_BenchmarkSecurityID;
  cBenchmarkSecurityID.trackObjects = 0;
  
  cLegLastQty.klass = rb_define_class_under(mQuickfix, "LegLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLastQty, (void *) &cLegLastQty);
  rb_define_alloc_func(cLegLastQty.klass, _wrap_LegLastQty_allocate);
  rb_define_method(cLegLastQty.klass, "initialize", VALUEFUNC(_wrap_new_LegLastQty), -1);
  cLegLastQty.mark = 0;
  cLegLastQty.destroy = (void (*)(void *)) free_FIX_LegLastQty;
  cLegLastQty.trackObjects = 0;
  
  cAllocSettlCurrency.klass = rb_define_class_under(mQuickfix, "AllocSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocSettlCurrency, (void *) &cAllocSettlCurrency);
  rb_define_alloc_func(cAllocSettlCurrency.klass, _wrap_AllocSettlCurrency_allocate);
  rb_define_method(cAllocSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_AllocSettlCurrency), -1);
  cAllocSettlCurrency.mark = 0;
  cAllocSettlCurrency.destroy = (void (*)(void *)) free_FIX_AllocSettlCurrency;
  cAllocSettlCurrency.trackObjects = 0;
  
  cLegCountryOfIssue.klass = rb_define_class_under(mQuickfix, "LegCountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCountryOfIssue, (void *) &cLegCountryOfIssue);
  rb_define_alloc_func(cLegCountryOfIssue.klass, _wrap_LegCountryOfIssue_allocate);
  rb_define_method(cLegCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LegCountryOfIssue), -1);
  cLegCountryOfIssue.mark = 0;
  cLegCountryOfIssue.destroy = (void (*)(void *)) free_FIX_LegCountryOfIssue;
  cLegCountryOfIssue.trackObjects = 0;
  
  cDerivativeSecurityXML.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityXML", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityXML, (void *) &cDerivativeSecurityXML);
  rb_define_alloc_func(cDerivativeSecurityXML.klass, _wrap_DerivativeSecurityXML_allocate);
  rb_define_method(cDerivativeSecurityXML.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityXML), -1);
  cDerivativeSecurityXML.mark = 0;
  cDerivativeSecurityXML.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityXML;
  cDerivativeSecurityXML.trackObjects = 0;
  
  cStrikeRuleID.klass = rb_define_class_under(mQuickfix, "StrikeRuleID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeRuleID, (void *) &cStrikeRuleID);
  rb_define_alloc_func(cStrikeRuleID.klass, _wrap_StrikeRuleID_allocate);
  rb_define_method(cStrikeRuleID.klass, "initialize", VALUEFUNC(_wrap_new_StrikeRuleID), -1);
  cStrikeRuleID.mark = 0;
  cStrikeRuleID.destroy = (void (*)(void *)) free_FIX_StrikeRuleID;
  cStrikeRuleID.trackObjects = 0;
  
  cRefCompID.klass = rb_define_class_under(mQuickfix, "RefCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefCompID, (void *) &cRefCompID);
  rb_define_alloc_func(cRefCompID.klass, _wrap_RefCompID_allocate);
  rb_define_method(cRefCompID.klass, "initialize", VALUEFUNC(_wrap_new_RefCompID), -1);
  cRefCompID.mark = 0;
  cRefCompID.destroy = (void (*)(void *)) free_FIX_RefCompID;
  cRefCompID.trackObjects = 0;
  
  cSettlCurrOfferFxRate.klass = rb_define_class_under(mQuickfix, "SettlCurrOfferFxRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrOfferFxRate, (void *) &cSettlCurrOfferFxRate);
  rb_define_alloc_func(cSettlCurrOfferFxRate.klass, _wrap_SettlCurrOfferFxRate_allocate);
  rb_define_method(cSettlCurrOfferFxRate.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrOfferFxRate), -1);
  cSettlCurrOfferFxRate.mark = 0;
  cSettlCurrOfferFxRate.destroy = (void (*)(void *)) free_FIX_SettlCurrOfferFxRate;
  cSettlCurrOfferFxRate.trackObjects = 0;
  
  cOfferYield.klass = rb_define_class_under(mQuickfix, "OfferYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferYield, (void *) &cOfferYield);
  rb_define_alloc_func(cOfferYield.klass, _wrap_OfferYield_allocate);
  rb_define_method(cOfferYield.klass, "initialize", VALUEFUNC(_wrap_new_OfferYield), -1);
  cOfferYield.mark = 0;
  cOfferYield.destroy = (void (*)(void *)) free_FIX_OfferYield;
  cOfferYield.trackObjects = 0;
  
  cRelatedContextPartyID.klass = rb_define_class_under(mQuickfix, "RelatedContextPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedContextPartyID, (void *) &cRelatedContextPartyID);
  rb_define_alloc_func(cRelatedContextPartyID.klass, _wrap_RelatedContextPartyID_allocate);
  rb_define_method(cRelatedContextPartyID.klass, "initialize", VALUEFUNC(_wrap_new_RelatedContextPartyID), -1);
  cRelatedContextPartyID.mark = 0;
  cRelatedContextPartyID.destroy = (void (*)(void *)) free_FIX_RelatedContextPartyID;
  cRelatedContextPartyID.trackObjects = 0;
  
  cTargetPartyIDSource.klass = rb_define_class_under(mQuickfix, "TargetPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetPartyIDSource, (void *) &cTargetPartyIDSource);
  rb_define_alloc_func(cTargetPartyIDSource.klass, _wrap_TargetPartyIDSource_allocate);
  rb_define_method(cTargetPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_TargetPartyIDSource), -1);
  cTargetPartyIDSource.mark = 0;
  cTargetPartyIDSource.destroy = (void (*)(void *)) free_FIX_TargetPartyIDSource;
  cTargetPartyIDSource.trackObjects = 0;
  
  cEncryptedNewPasswordLen.klass = rb_define_class_under(mQuickfix, "EncryptedNewPasswordLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedNewPasswordLen, (void *) &cEncryptedNewPasswordLen);
  rb_define_alloc_func(cEncryptedNewPasswordLen.klass, _wrap_EncryptedNewPasswordLen_allocate);
  rb_define_method(cEncryptedNewPasswordLen.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedNewPasswordLen), -1);
  cEncryptedNewPasswordLen.mark = 0;
  cEncryptedNewPasswordLen.destroy = (void (*)(void *)) free_FIX_EncryptedNewPasswordLen;
  cEncryptedNewPasswordLen.trackObjects = 0;
  
  cNoPositions.klass = rb_define_class_under(mQuickfix, "NoPositions", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPositions, (void *) &cNoPositions);
  rb_define_alloc_func(cNoPositions.klass, _wrap_NoPositions_allocate);
  rb_define_method(cNoPositions.klass, "initialize", VALUEFUNC(_wrap_new_NoPositions), -1);
  cNoPositions.mark = 0;
  cNoPositions.destroy = (void (*)(void *)) free_FIX_NoPositions;
  cNoPositions.trackObjects = 0;
  
  cTotalAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "TotalAccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalAccruedInterestAmt, (void *) &cTotalAccruedInterestAmt);
  rb_define_alloc_func(cTotalAccruedInterestAmt.klass, _wrap_TotalAccruedInterestAmt_allocate);
  rb_define_method(cTotalAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_TotalAccruedInterestAmt), -1);
  cTotalAccruedInterestAmt.mark = 0;
  cTotalAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_TotalAccruedInterestAmt;
  cTotalAccruedInterestAmt.trackObjects = 0;
  
  cUnderlyingOptAttribute.klass = rb_define_class_under(mQuickfix, "UnderlyingOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingOptAttribute, (void *) &cUnderlyingOptAttribute);
  rb_define_alloc_func(cUnderlyingOptAttribute.klass, _wrap_UnderlyingOptAttribute_allocate);
  rb_define_method(cUnderlyingOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingOptAttribute), -1);
  cUnderlyingOptAttribute.mark = 0;
  cUnderlyingOptAttribute.destroy = (void (*)(void *)) free_FIX_UnderlyingOptAttribute;
  cUnderlyingOptAttribute.trackObjects = 0;
  
  cDerivativeInstrAttribValue.klass = rb_define_class_under(mQuickfix, "DerivativeInstrAttribValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrAttribValue, (void *) &cDerivativeInstrAttribValue);
  rb_define_alloc_func(cDerivativeInstrAttribValue.klass, _wrap_DerivativeInstrAttribValue_allocate);
  rb_define_method(cDerivativeInstrAttribValue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrAttribValue), -1);
  cDerivativeInstrAttribValue.mark = 0;
  cDerivativeInstrAttribValue.destroy = (void (*)(void *)) free_FIX_DerivativeInstrAttribValue;
  cDerivativeInstrAttribValue.trackObjects = 0;
  
  cInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "InstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartyIDSource, (void *) &cInstrumentPartyIDSource);
  rb_define_alloc_func(cInstrumentPartyIDSource.klass, _wrap_InstrumentPartyIDSource_allocate);
  rb_define_method(cInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartyIDSource), -1);
  cInstrumentPartyIDSource.mark = 0;
  cInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_InstrumentPartyIDSource;
  cInstrumentPartyIDSource.trackObjects = 0;
  
  cPegOffsetType.klass = rb_define_class_under(mQuickfix, "PegOffsetType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegOffsetType, (void *) &cPegOffsetType);
  rb_define_alloc_func(cPegOffsetType.klass, _wrap_PegOffsetType_allocate);
  rb_define_method(cPegOffsetType.klass, "initialize", VALUEFUNC(_wrap_new_PegOffsetType), -1);
  cPegOffsetType.mark = 0;
  cPegOffsetType.destroy = (void (*)(void *)) free_FIX_PegOffsetType;
  cPegOffsetType.trackObjects = 0;
  
  cMassCancelRejectReason.klass = rb_define_class_under(mQuickfix, "MassCancelRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassCancelRejectReason, (void *) &cMassCancelRejectReason);
  rb_define_alloc_func(cMassCancelRejectReason.klass, _wrap_MassCancelRejectReason_allocate);
  rb_define_method(cMassCancelRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_MassCancelRejectReason), -1);
  cMassCancelRejectReason.mark = 0;
  cMassCancelRejectReason.destroy = (void (*)(void *)) free_FIX_MassCancelRejectReason;
  cMassCancelRejectReason.trackObjects = 0;
  
  cResponseTransportType.klass = rb_define_class_under(mQuickfix, "ResponseTransportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ResponseTransportType, (void *) &cResponseTransportType);
  rb_define_alloc_func(cResponseTransportType.klass, _wrap_ResponseTransportType_allocate);
  rb_define_method(cResponseTransportType.klass, "initialize", VALUEFUNC(_wrap_new_ResponseTransportType), -1);
  cResponseTransportType.mark = 0;
  cResponseTransportType.destroy = (void (*)(void *)) free_FIX_ResponseTransportType;
  cResponseTransportType.trackObjects = 0;
  
  cLegSecurityIDSource.klass = rb_define_class_under(mQuickfix, "LegSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityIDSource, (void *) &cLegSecurityIDSource);
  rb_define_alloc_func(cLegSecurityIDSource.klass, _wrap_LegSecurityIDSource_allocate);
  rb_define_method(cLegSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityIDSource), -1);
  cLegSecurityIDSource.mark = 0;
  cLegSecurityIDSource.destroy = (void (*)(void *)) free_FIX_LegSecurityIDSource;
  cLegSecurityIDSource.trackObjects = 0;
  
  cBasisFeaturePrice.klass = rb_define_class_under(mQuickfix, "BasisFeaturePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BasisFeaturePrice, (void *) &cBasisFeaturePrice);
  rb_define_alloc_func(cBasisFeaturePrice.klass, _wrap_BasisFeaturePrice_allocate);
  rb_define_method(cBasisFeaturePrice.klass, "initialize", VALUEFUNC(_wrap_new_BasisFeaturePrice), -1);
  cBasisFeaturePrice.mark = 0;
  cBasisFeaturePrice.destroy = (void (*)(void *)) free_FIX_BasisFeaturePrice;
  cBasisFeaturePrice.trackObjects = 0;
  
  cCouponPaymentDate.klass = rb_define_class_under(mQuickfix, "CouponPaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CouponPaymentDate, (void *) &cCouponPaymentDate);
  rb_define_alloc_func(cCouponPaymentDate.klass, _wrap_CouponPaymentDate_allocate);
  rb_define_method(cCouponPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_CouponPaymentDate), -1);
  cCouponPaymentDate.mark = 0;
  cCouponPaymentDate.destroy = (void (*)(void *)) free_FIX_CouponPaymentDate;
  cCouponPaymentDate.trackObjects = 0;
  
  cTradSesStatusRejReason.klass = rb_define_class_under(mQuickfix, "TradSesStatusRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesStatusRejReason, (void *) &cTradSesStatusRejReason);
  rb_define_alloc_func(cTradSesStatusRejReason.klass, _wrap_TradSesStatusRejReason_allocate);
  rb_define_method(cTradSesStatusRejReason.klass, "initialize", VALUEFUNC(_wrap_new_TradSesStatusRejReason), -1);
  cTradSesStatusRejReason.mark = 0;
  cTradSesStatusRejReason.destroy = (void (*)(void *)) free_FIX_TradSesStatusRejReason;
  cTradSesStatusRejReason.trackObjects = 0;
  
  cUnderlyingDetachmentPoint.klass = rb_define_class_under(mQuickfix, "UnderlyingDetachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingDetachmentPoint, (void *) &cUnderlyingDetachmentPoint);
  rb_define_alloc_func(cUnderlyingDetachmentPoint.klass, _wrap_UnderlyingDetachmentPoint_allocate);
  rb_define_method(cUnderlyingDetachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingDetachmentPoint), -1);
  cUnderlyingDetachmentPoint.mark = 0;
  cUnderlyingDetachmentPoint.destroy = (void (*)(void *)) free_FIX_UnderlyingDetachmentPoint;
  cUnderlyingDetachmentPoint.trackObjects = 0;
  
  cMaturityRuleID.klass = rb_define_class_under(mQuickfix, "MaturityRuleID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityRuleID, (void *) &cMaturityRuleID);
  rb_define_alloc_func(cMaturityRuleID.klass, _wrap_MaturityRuleID_allocate);
  rb_define_method(cMaturityRuleID.klass, "initialize", VALUEFUNC(_wrap_new_MaturityRuleID), -1);
  cMaturityRuleID.mark = 0;
  cMaturityRuleID.destroy = (void (*)(void *)) free_FIX_MaturityRuleID;
  cMaturityRuleID.trackObjects = 0;
  
  cUnderlyingRepoCollateralSecurityType.klass = rb_define_class_under(mQuickfix, "UnderlyingRepoCollateralSecurityType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRepoCollateralSecurityType, (void *) &cUnderlyingRepoCollateralSecurityType);
  rb_define_alloc_func(cUnderlyingRepoCollateralSecurityType.klass, _wrap_UnderlyingRepoCollateralSecurityType_allocate);
  rb_define_method(cUnderlyingRepoCollateralSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRepoCollateralSecurityType), -1);
  cUnderlyingRepoCollateralSecurityType.mark = 0;
  cUnderlyingRepoCollateralSecurityType.destroy = (void (*)(void *)) free_FIX_UnderlyingRepoCollateralSecurityType;
  cUnderlyingRepoCollateralSecurityType.trackObjects = 0;
  
  cNoTimeInForceRules.klass = rb_define_class_under(mQuickfix, "NoTimeInForceRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTimeInForceRules, (void *) &cNoTimeInForceRules);
  rb_define_alloc_func(cNoTimeInForceRules.klass, _wrap_NoTimeInForceRules_allocate);
  rb_define_method(cNoTimeInForceRules.klass, "initialize", VALUEFUNC(_wrap_new_NoTimeInForceRules), -1);
  cNoTimeInForceRules.mark = 0;
  cNoTimeInForceRules.destroy = (void (*)(void *)) free_FIX_NoTimeInForceRules;
  cNoTimeInForceRules.trackObjects = 0;
  
  cNoRootPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoRootPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRootPartySubIDs, (void *) &cNoRootPartySubIDs);
  rb_define_alloc_func(cNoRootPartySubIDs.klass, _wrap_NoRootPartySubIDs_allocate);
  rb_define_method(cNoRootPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRootPartySubIDs), -1);
  cNoRootPartySubIDs.mark = 0;
  cNoRootPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoRootPartySubIDs;
  cNoRootPartySubIDs.trackObjects = 0;
  
  cDisplayMinIncr.klass = rb_define_class_under(mQuickfix, "DisplayMinIncr", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayMinIncr, (void *) &cDisplayMinIncr);
  rb_define_alloc_func(cDisplayMinIncr.klass, _wrap_DisplayMinIncr_allocate);
  rb_define_method(cDisplayMinIncr.klass, "initialize", VALUEFUNC(_wrap_new_DisplayMinIncr), -1);
  cDisplayMinIncr.mark = 0;
  cDisplayMinIncr.destroy = (void (*)(void *)) free_FIX_DisplayMinIncr;
  cDisplayMinIncr.trackObjects = 0;
  
  cTrdRegTimestampType.klass = rb_define_class_under(mQuickfix, "TrdRegTimestampType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRegTimestampType, (void *) &cTrdRegTimestampType);
  rb_define_alloc_func(cTrdRegTimestampType.klass, _wrap_TrdRegTimestampType_allocate);
  rb_define_method(cTrdRegTimestampType.klass, "initialize", VALUEFUNC(_wrap_new_TrdRegTimestampType), -1);
  cTrdRegTimestampType.mark = 0;
  cTrdRegTimestampType.destroy = (void (*)(void *)) free_FIX_TrdRegTimestampType;
  cTrdRegTimestampType.trackObjects = 0;
  
  cLegProduct.klass = rb_define_class_under(mQuickfix, "LegProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegProduct, (void *) &cLegProduct);
  rb_define_alloc_func(cLegProduct.klass, _wrap_LegProduct_allocate);
  rb_define_method(cLegProduct.klass, "initialize", VALUEFUNC(_wrap_new_LegProduct), -1);
  cLegProduct.mark = 0;
  cLegProduct.destroy = (void (*)(void *)) free_FIX_LegProduct;
  cLegProduct.trackObjects = 0;
  
  cApplVerID.klass = rb_define_class_under(mQuickfix, "ApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplVerID, (void *) &cApplVerID);
  rb_define_alloc_func(cApplVerID.klass, _wrap_ApplVerID_allocate);
  rb_define_method(cApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_ApplVerID), -1);
  cApplVerID.mark = 0;
  cApplVerID.destroy = (void (*)(void *)) free_FIX_ApplVerID;
  cApplVerID.trackObjects = 0;
  
  cHandlInst.klass = rb_define_class_under(mQuickfix, "HandlInst", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HandlInst, (void *) &cHandlInst);
  rb_define_alloc_func(cHandlInst.klass, _wrap_HandlInst_allocate);
  rb_define_method(cHandlInst.klass, "initialize", VALUEFUNC(_wrap_new_HandlInst), -1);
  cHandlInst.mark = 0;
  cHandlInst.destroy = (void (*)(void *)) free_FIX_HandlInst;
  cHandlInst.trackObjects = 0;
  
  cListUpdateAction.klass = rb_define_class_under(mQuickfix, "ListUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListUpdateAction, (void *) &cListUpdateAction);
  rb_define_alloc_func(cListUpdateAction.klass, _wrap_ListUpdateAction_allocate);
  rb_define_method(cListUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_ListUpdateAction), -1);
  cListUpdateAction.mark = 0;
  cListUpdateAction.destroy = (void (*)(void *)) free_FIX_ListUpdateAction;
  cListUpdateAction.trackObjects = 0;
  
  cNestedInstrAttribValue.klass = rb_define_class_under(mQuickfix, "NestedInstrAttribValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedInstrAttribValue, (void *) &cNestedInstrAttribValue);
  rb_define_alloc_func(cNestedInstrAttribValue.klass, _wrap_NestedInstrAttribValue_allocate);
  rb_define_method(cNestedInstrAttribValue.klass, "initialize", VALUEFUNC(_wrap_new_NestedInstrAttribValue), -1);
  cNestedInstrAttribValue.mark = 0;
  cNestedInstrAttribValue.destroy = (void (*)(void *)) free_FIX_NestedInstrAttribValue;
  cNestedInstrAttribValue.trackObjects = 0;
  
  cTradingSessionSubID.klass = rb_define_class_under(mQuickfix, "TradingSessionSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingSessionSubID, (void *) &cTradingSessionSubID);
  rb_define_alloc_func(cTradingSessionSubID.klass, _wrap_TradingSessionSubID_allocate);
  rb_define_method(cTradingSessionSubID.klass, "initialize", VALUEFUNC(_wrap_new_TradingSessionSubID), -1);
  cTradingSessionSubID.mark = 0;
  cTradingSessionSubID.destroy = (void (*)(void *)) free_FIX_TradingSessionSubID;
  cTradingSessionSubID.trackObjects = 0;
  
  cRFQReqID.klass = rb_define_class_under(mQuickfix, "RFQReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RFQReqID, (void *) &cRFQReqID);
  rb_define_alloc_func(cRFQReqID.klass, _wrap_RFQReqID_allocate);
  rb_define_method(cRFQReqID.klass, "initialize", VALUEFUNC(_wrap_new_RFQReqID), -1);
  cRFQReqID.mark = 0;
  cRFQReqID.destroy = (void (*)(void *)) free_FIX_RFQReqID;
  cRFQReqID.trackObjects = 0;
  
  cRelationshipRiskSecurityExchange.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityExchange, (void *) &cRelationshipRiskSecurityExchange);
  rb_define_alloc_func(cRelationshipRiskSecurityExchange.klass, _wrap_RelationshipRiskSecurityExchange_allocate);
  rb_define_method(cRelationshipRiskSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityExchange), -1);
  cRelationshipRiskSecurityExchange.mark = 0;
  cRelationshipRiskSecurityExchange.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityExchange;
  cRelationshipRiskSecurityExchange.trackObjects = 0;
  
  cUnderlyingLegSymbolSfx.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSymbolSfx, (void *) &cUnderlyingLegSymbolSfx);
  rb_define_alloc_func(cUnderlyingLegSymbolSfx.klass, _wrap_UnderlyingLegSymbolSfx_allocate);
  rb_define_method(cUnderlyingLegSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSymbolSfx), -1);
  cUnderlyingLegSymbolSfx.mark = 0;
  cUnderlyingLegSymbolSfx.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSymbolSfx;
  cUnderlyingLegSymbolSfx.trackObjects = 0;
  
  cLiquidityNumSecurities.klass = rb_define_class_under(mQuickfix, "LiquidityNumSecurities", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityNumSecurities, (void *) &cLiquidityNumSecurities);
  rb_define_alloc_func(cLiquidityNumSecurities.klass, _wrap_LiquidityNumSecurities_allocate);
  rb_define_method(cLiquidityNumSecurities.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityNumSecurities), -1);
  cLiquidityNumSecurities.mark = 0;
  cLiquidityNumSecurities.destroy = (void (*)(void *)) free_FIX_LiquidityNumSecurities;
  cLiquidityNumSecurities.trackObjects = 0;
  
  cNoMsgTypes.klass = rb_define_class_under(mQuickfix, "NoMsgTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMsgTypes, (void *) &cNoMsgTypes);
  rb_define_alloc_func(cNoMsgTypes.klass, _wrap_NoMsgTypes_allocate);
  rb_define_method(cNoMsgTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoMsgTypes), -1);
  cNoMsgTypes.mark = 0;
  cNoMsgTypes.destroy = (void (*)(void *)) free_FIX_NoMsgTypes;
  cNoMsgTypes.trackObjects = 0;
  
  cTradSesStartTime.klass = rb_define_class_under(mQuickfix, "TradSesStartTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesStartTime, (void *) &cTradSesStartTime);
  rb_define_alloc_func(cTradSesStartTime.klass, _wrap_TradSesStartTime_allocate);
  rb_define_method(cTradSesStartTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesStartTime), -1);
  cTradSesStartTime.mark = 0;
  cTradSesStartTime.destroy = (void (*)(void *)) free_FIX_TradSesStartTime;
  cTradSesStartTime.trackObjects = 0;
  
  cMDEntryType.klass = rb_define_class_under(mQuickfix, "MDEntryType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryType, (void *) &cMDEntryType);
  rb_define_alloc_func(cMDEntryType.klass, _wrap_MDEntryType_allocate);
  rb_define_method(cMDEntryType.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryType), -1);
  cMDEntryType.mark = 0;
  cMDEntryType.destroy = (void (*)(void *)) free_FIX_MDEntryType;
  cMDEntryType.trackObjects = 0;
  
  cAgreementCurrency.klass = rb_define_class_under(mQuickfix, "AgreementCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementCurrency, (void *) &cAgreementCurrency);
  rb_define_alloc_func(cAgreementCurrency.klass, _wrap_AgreementCurrency_allocate);
  rb_define_method(cAgreementCurrency.klass, "initialize", VALUEFUNC(_wrap_new_AgreementCurrency), -1);
  cAgreementCurrency.mark = 0;
  cAgreementCurrency.destroy = (void (*)(void *)) free_FIX_AgreementCurrency;
  cAgreementCurrency.trackObjects = 0;
  
  cPegMoveType.klass = rb_define_class_under(mQuickfix, "PegMoveType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegMoveType, (void *) &cPegMoveType);
  rb_define_alloc_func(cPegMoveType.klass, _wrap_PegMoveType_allocate);
  rb_define_method(cPegMoveType.klass, "initialize", VALUEFUNC(_wrap_new_PegMoveType), -1);
  cPegMoveType.mark = 0;
  cPegMoveType.destroy = (void (*)(void *)) free_FIX_PegMoveType;
  cPegMoveType.trackObjects = 0;
  
  cAsgnReqID.klass = rb_define_class_under(mQuickfix, "AsgnReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AsgnReqID, (void *) &cAsgnReqID);
  rb_define_alloc_func(cAsgnReqID.klass, _wrap_AsgnReqID_allocate);
  rb_define_method(cAsgnReqID.klass, "initialize", VALUEFUNC(_wrap_new_AsgnReqID), -1);
  cAsgnReqID.mark = 0;
  cAsgnReqID.destroy = (void (*)(void *)) free_FIX_AsgnReqID;
  cAsgnReqID.trackObjects = 0;
  
  cPegDifference.klass = rb_define_class_under(mQuickfix, "PegDifference", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegDifference, (void *) &cPegDifference);
  rb_define_alloc_func(cPegDifference.klass, _wrap_PegDifference_allocate);
  rb_define_method(cPegDifference.klass, "initialize", VALUEFUNC(_wrap_new_PegDifference), -1);
  cPegDifference.mark = 0;
  cPegDifference.destroy = (void (*)(void *)) free_FIX_PegDifference;
  cPegDifference.trackObjects = 0;
  
  cSpread.klass = rb_define_class_under(mQuickfix, "Spread", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Spread, (void *) &cSpread);
  rb_define_alloc_func(cSpread.klass, _wrap_Spread_allocate);
  rb_define_method(cSpread.klass, "initialize", VALUEFUNC(_wrap_new_Spread), -1);
  cSpread.mark = 0;
  cSpread.destroy = (void (*)(void *)) free_FIX_Spread;
  cSpread.trackObjects = 0;
  
  cEncodedAllocTextLen.klass = rb_define_class_under(mQuickfix, "EncodedAllocTextLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedAllocTextLen, (void *) &cEncodedAllocTextLen);
  rb_define_alloc_func(cEncodedAllocTextLen.klass, _wrap_EncodedAllocTextLen_allocate);
  rb_define_method(cEncodedAllocTextLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedAllocTextLen), -1);
  cEncodedAllocTextLen.mark = 0;
  cEncodedAllocTextLen.destroy = (void (*)(void *)) free_FIX_EncodedAllocTextLen;
  cEncodedAllocTextLen.trackObjects = 0;
  
  cOutsideIndexPct.klass = rb_define_class_under(mQuickfix, "OutsideIndexPct", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OutsideIndexPct, (void *) &cOutsideIndexPct);
  rb_define_alloc_func(cOutsideIndexPct.klass, _wrap_OutsideIndexPct_allocate);
  rb_define_method(cOutsideIndexPct.klass, "initialize", VALUEFUNC(_wrap_new_OutsideIndexPct), -1);
  cOutsideIndexPct.mark = 0;
  cOutsideIndexPct.destroy = (void (*)(void *)) free_FIX_OutsideIndexPct;
  cOutsideIndexPct.trackObjects = 0;
  
  cDerivFlexProductEligibilityIndicator.klass = rb_define_class_under(mQuickfix, "DerivFlexProductEligibilityIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivFlexProductEligibilityIndicator, (void *) &cDerivFlexProductEligibilityIndicator);
  rb_define_alloc_func(cDerivFlexProductEligibilityIndicator.klass, _wrap_DerivFlexProductEligibilityIndicator_allocate);
  rb_define_method(cDerivFlexProductEligibilityIndicator.klass, "initialize", VALUEFUNC(_wrap_new_DerivFlexProductEligibilityIndicator), -1);
  cDerivFlexProductEligibilityIndicator.mark = 0;
  cDerivFlexProductEligibilityIndicator.destroy = (void (*)(void *)) free_FIX_DerivFlexProductEligibilityIndicator;
  cDerivFlexProductEligibilityIndicator.trackObjects = 0;
  
  cAvgPxIndicator.klass = rb_define_class_under(mQuickfix, "AvgPxIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPxIndicator, (void *) &cAvgPxIndicator);
  rb_define_alloc_func(cAvgPxIndicator.klass, _wrap_AvgPxIndicator_allocate);
  rb_define_method(cAvgPxIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AvgPxIndicator), -1);
  cAvgPxIndicator.mark = 0;
  cAvgPxIndicator.destroy = (void (*)(void *)) free_FIX_AvgPxIndicator;
  cAvgPxIndicator.trackObjects = 0;
  
  cNoIOIQualifiers.klass = rb_define_class_under(mQuickfix, "NoIOIQualifiers", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoIOIQualifiers, (void *) &cNoIOIQualifiers);
  rb_define_alloc_func(cNoIOIQualifiers.klass, _wrap_NoIOIQualifiers_allocate);
  rb_define_method(cNoIOIQualifiers.klass, "initialize", VALUEFUNC(_wrap_new_NoIOIQualifiers), -1);
  cNoIOIQualifiers.mark = 0;
  cNoIOIQualifiers.destroy = (void (*)(void *)) free_FIX_NoIOIQualifiers;
  cNoIOIQualifiers.trackObjects = 0;
  
  cCancellationRights.klass = rb_define_class_under(mQuickfix, "CancellationRights", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CancellationRights, (void *) &cCancellationRights);
  rb_define_alloc_func(cCancellationRights.klass, _wrap_CancellationRights_allocate);
  rb_define_method(cCancellationRights.klass, "initialize", VALUEFUNC(_wrap_new_CancellationRights), -1);
  cCancellationRights.mark = 0;
  cCancellationRights.destroy = (void (*)(void *)) free_FIX_CancellationRights;
  cCancellationRights.trackObjects = 0;
  
  cListSeqNo.klass = rb_define_class_under(mQuickfix, "ListSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListSeqNo, (void *) &cListSeqNo);
  rb_define_alloc_func(cListSeqNo.klass, _wrap_ListSeqNo_allocate);
  rb_define_method(cListSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_ListSeqNo), -1);
  cListSeqNo.mark = 0;
  cListSeqNo.destroy = (void (*)(void *)) free_FIX_ListSeqNo;
  cListSeqNo.trackObjects = 0;
  
  cCardIssNum.klass = rb_define_class_under(mQuickfix, "CardIssNum", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardIssNum, (void *) &cCardIssNum);
  rb_define_alloc_func(cCardIssNum.klass, _wrap_CardIssNum_allocate);
  rb_define_method(cCardIssNum.klass, "initialize", VALUEFUNC(_wrap_new_CardIssNum), -1);
  cCardIssNum.mark = 0;
  cCardIssNum.destroy = (void (*)(void *)) free_FIX_CardIssNum;
  cCardIssNum.trackObjects = 0;
  
  cRiskCFICode.klass = rb_define_class_under(mQuickfix, "RiskCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskCFICode, (void *) &cRiskCFICode);
  rb_define_alloc_func(cRiskCFICode.klass, _wrap_RiskCFICode_allocate);
  rb_define_method(cRiskCFICode.klass, "initialize", VALUEFUNC(_wrap_new_RiskCFICode), -1);
  cRiskCFICode.mark = 0;
  cRiskCFICode.destroy = (void (*)(void *)) free_FIX_RiskCFICode;
  cRiskCFICode.trackObjects = 0;
  
  cEncodedMktSegmDesc.klass = rb_define_class_under(mQuickfix, "EncodedMktSegmDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedMktSegmDesc, (void *) &cEncodedMktSegmDesc);
  rb_define_alloc_func(cEncodedMktSegmDesc.klass, _wrap_EncodedMktSegmDesc_allocate);
  rb_define_method(cEncodedMktSegmDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedMktSegmDesc), -1);
  cEncodedMktSegmDesc.mark = 0;
  cEncodedMktSegmDesc.destroy = (void (*)(void *)) free_FIX_EncodedMktSegmDesc;
  cEncodedMktSegmDesc.trackObjects = 0;
  
  cDerivativeEventType.klass = rb_define_class_under(mQuickfix, "DerivativeEventType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventType, (void *) &cDerivativeEventType);
  rb_define_alloc_func(cDerivativeEventType.klass, _wrap_DerivativeEventType_allocate);
  rb_define_method(cDerivativeEventType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventType), -1);
  cDerivativeEventType.mark = 0;
  cDerivativeEventType.destroy = (void (*)(void *)) free_FIX_DerivativeEventType;
  cDerivativeEventType.trackObjects = 0;
  
  cDerivativeMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "DerivativeMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMaturityMonthYear, (void *) &cDerivativeMaturityMonthYear);
  rb_define_alloc_func(cDerivativeMaturityMonthYear.klass, _wrap_DerivativeMaturityMonthYear_allocate);
  rb_define_method(cDerivativeMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMaturityMonthYear), -1);
  cDerivativeMaturityMonthYear.mark = 0;
  cDerivativeMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_DerivativeMaturityMonthYear;
  cDerivativeMaturityMonthYear.trackObjects = 0;
  
  cSideTradeReportID.klass = rb_define_class_under(mQuickfix, "SideTradeReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTradeReportID, (void *) &cSideTradeReportID);
  rb_define_alloc_func(cSideTradeReportID.klass, _wrap_SideTradeReportID_allocate);
  rb_define_method(cSideTradeReportID.klass, "initialize", VALUEFUNC(_wrap_new_SideTradeReportID), -1);
  cSideTradeReportID.mark = 0;
  cSideTradeReportID.destroy = (void (*)(void *)) free_FIX_SideTradeReportID;
  cSideTradeReportID.trackObjects = 0;
  
  cNoQuoteSets.klass = rb_define_class_under(mQuickfix, "NoQuoteSets", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoQuoteSets, (void *) &cNoQuoteSets);
  rb_define_alloc_func(cNoQuoteSets.klass, _wrap_NoQuoteSets_allocate);
  rb_define_method(cNoQuoteSets.klass, "initialize", VALUEFUNC(_wrap_new_NoQuoteSets), -1);
  cNoQuoteSets.mark = 0;
  cNoQuoteSets.destroy = (void (*)(void *)) free_FIX_NoQuoteSets;
  cNoQuoteSets.trackObjects = 0;
  
  cRelationshipRiskSecurityDesc.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityDesc, (void *) &cRelationshipRiskSecurityDesc);
  rb_define_alloc_func(cRelationshipRiskSecurityDesc.klass, _wrap_RelationshipRiskSecurityDesc_allocate);
  rb_define_method(cRelationshipRiskSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityDesc), -1);
  cRelationshipRiskSecurityDesc.mark = 0;
  cRelationshipRiskSecurityDesc.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityDesc;
  cRelationshipRiskSecurityDesc.trackObjects = 0;
  
  cNested4PartySubIDType.klass = rb_define_class_under(mQuickfix, "Nested4PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartySubIDType, (void *) &cNested4PartySubIDType);
  rb_define_alloc_func(cNested4PartySubIDType.klass, _wrap_Nested4PartySubIDType_allocate);
  rb_define_method(cNested4PartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartySubIDType), -1);
  cNested4PartySubIDType.mark = 0;
  cNested4PartySubIDType.destroy = (void (*)(void *)) free_FIX_Nested4PartySubIDType;
  cNested4PartySubIDType.trackObjects = 0;
  
  cFillPx.klass = rb_define_class_under(mQuickfix, "FillPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillPx, (void *) &cFillPx);
  rb_define_alloc_func(cFillPx.klass, _wrap_FillPx_allocate);
  rb_define_method(cFillPx.klass, "initialize", VALUEFUNC(_wrap_new_FillPx), -1);
  cFillPx.mark = 0;
  cFillPx.destroy = (void (*)(void *)) free_FIX_FillPx;
  cFillPx.trackObjects = 0;
  
  cStrikeExerciseStyle.klass = rb_define_class_under(mQuickfix, "StrikeExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeExerciseStyle, (void *) &cStrikeExerciseStyle);
  rb_define_alloc_func(cStrikeExerciseStyle.klass, _wrap_StrikeExerciseStyle_allocate);
  rb_define_method(cStrikeExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_StrikeExerciseStyle), -1);
  cStrikeExerciseStyle.mark = 0;
  cStrikeExerciseStyle.destroy = (void (*)(void *)) free_FIX_StrikeExerciseStyle;
  cStrikeExerciseStyle.trackObjects = 0;
  
  cDeskID.klass = rb_define_class_under(mQuickfix, "DeskID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskID, (void *) &cDeskID);
  rb_define_alloc_func(cDeskID.klass, _wrap_DeskID_allocate);
  rb_define_method(cDeskID.klass, "initialize", VALUEFUNC(_wrap_new_DeskID), -1);
  cDeskID.mark = 0;
  cDeskID.destroy = (void (*)(void *)) free_FIX_DeskID;
  cDeskID.trackObjects = 0;
  
  cCrossPercent.klass = rb_define_class_under(mQuickfix, "CrossPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossPercent, (void *) &cCrossPercent);
  rb_define_alloc_func(cCrossPercent.klass, _wrap_CrossPercent_allocate);
  rb_define_method(cCrossPercent.klass, "initialize", VALUEFUNC(_wrap_new_CrossPercent), -1);
  cCrossPercent.mark = 0;
  cCrossPercent.destroy = (void (*)(void *)) free_FIX_CrossPercent;
  cCrossPercent.trackObjects = 0;
  
  cMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "MaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYear, (void *) &cMaturityMonthYear);
  rb_define_alloc_func(cMaturityMonthYear.klass, _wrap_MaturityMonthYear_allocate);
  rb_define_method(cMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYear), -1);
  cMaturityMonthYear.mark = 0;
  cMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_MaturityMonthYear;
  cMaturityMonthYear.trackObjects = 0;
  
  cComplexEventPrice.klass = rb_define_class_under(mQuickfix, "ComplexEventPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPrice, (void *) &cComplexEventPrice);
  rb_define_alloc_func(cComplexEventPrice.klass, _wrap_ComplexEventPrice_allocate);
  rb_define_method(cComplexEventPrice.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPrice), -1);
  cComplexEventPrice.mark = 0;
  cComplexEventPrice.destroy = (void (*)(void *)) free_FIX_ComplexEventPrice;
  cComplexEventPrice.trackObjects = 0;
  
  cNoNewsRefIDs.klass = rb_define_class_under(mQuickfix, "NoNewsRefIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNewsRefIDs, (void *) &cNoNewsRefIDs);
  rb_define_alloc_func(cNoNewsRefIDs.klass, _wrap_NoNewsRefIDs_allocate);
  rb_define_method(cNoNewsRefIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNewsRefIDs), -1);
  cNoNewsRefIDs.mark = 0;
  cNoNewsRefIDs.destroy = (void (*)(void *)) free_FIX_NoNewsRefIDs;
  cNoNewsRefIDs.trackObjects = 0;
  
  cUnderlyingCapValue.klass = rb_define_class_under(mQuickfix, "UnderlyingCapValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCapValue, (void *) &cUnderlyingCapValue);
  rb_define_alloc_func(cUnderlyingCapValue.klass, _wrap_UnderlyingCapValue_allocate);
  rb_define_method(cUnderlyingCapValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCapValue), -1);
  cUnderlyingCapValue.mark = 0;
  cUnderlyingCapValue.destroy = (void (*)(void *)) free_FIX_UnderlyingCapValue;
  cUnderlyingCapValue.trackObjects = 0;
  
  cCPRegType.klass = rb_define_class_under(mQuickfix, "CPRegType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CPRegType, (void *) &cCPRegType);
  rb_define_alloc_func(cCPRegType.klass, _wrap_CPRegType_allocate);
  rb_define_method(cCPRegType.klass, "initialize", VALUEFUNC(_wrap_new_CPRegType), -1);
  cCPRegType.mark = 0;
  cCPRegType.destroy = (void (*)(void *)) free_FIX_CPRegType;
  cCPRegType.trackObjects = 0;
  
  cCashDistribAgentCode.klass = rb_define_class_under(mQuickfix, "CashDistribAgentCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentCode, (void *) &cCashDistribAgentCode);
  rb_define_alloc_func(cCashDistribAgentCode.klass, _wrap_CashDistribAgentCode_allocate);
  rb_define_method(cCashDistribAgentCode.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentCode), -1);
  cCashDistribAgentCode.mark = 0;
  cCashDistribAgentCode.destroy = (void (*)(void *)) free_FIX_CashDistribAgentCode;
  cCashDistribAgentCode.trackObjects = 0;
  
  cExecPriceType.klass = rb_define_class_under(mQuickfix, "ExecPriceType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecPriceType, (void *) &cExecPriceType);
  rb_define_alloc_func(cExecPriceType.klass, _wrap_ExecPriceType_allocate);
  rb_define_method(cExecPriceType.klass, "initialize", VALUEFUNC(_wrap_new_ExecPriceType), -1);
  cExecPriceType.mark = 0;
  cExecPriceType.destroy = (void (*)(void *)) free_FIX_ExecPriceType;
  cExecPriceType.trackObjects = 0;
  
  cLegAllocID.klass = rb_define_class_under(mQuickfix, "LegAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocID, (void *) &cLegAllocID);
  rb_define_alloc_func(cLegAllocID.klass, _wrap_LegAllocID_allocate);
  rb_define_method(cLegAllocID.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocID), -1);
  cLegAllocID.mark = 0;
  cLegAllocID.destroy = (void (*)(void *)) free_FIX_LegAllocID;
  cLegAllocID.trackObjects = 0;
  
  cMDEntryTime.klass = rb_define_class_under(mQuickfix, "MDEntryTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryTime, (void *) &cMDEntryTime);
  rb_define_alloc_func(cMDEntryTime.klass, _wrap_MDEntryTime_allocate);
  rb_define_method(cMDEntryTime.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryTime), -1);
  cMDEntryTime.mark = 0;
  cMDEntryTime.destroy = (void (*)(void *)) free_FIX_MDEntryTime;
  cMDEntryTime.trackObjects = 0;
  
  cTotalNumSecurities.klass = rb_define_class_under(mQuickfix, "TotalNumSecurities", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNumSecurities, (void *) &cTotalNumSecurities);
  rb_define_alloc_func(cTotalNumSecurities.klass, _wrap_TotalNumSecurities_allocate);
  rb_define_method(cTotalNumSecurities.klass, "initialize", VALUEFUNC(_wrap_new_TotalNumSecurities), -1);
  cTotalNumSecurities.mark = 0;
  cTotalNumSecurities.destroy = (void (*)(void *)) free_FIX_TotalNumSecurities;
  cTotalNumSecurities.trackObjects = 0;
  
  cAllocSettlInstType.klass = rb_define_class_under(mQuickfix, "AllocSettlInstType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocSettlInstType, (void *) &cAllocSettlInstType);
  rb_define_alloc_func(cAllocSettlInstType.klass, _wrap_AllocSettlInstType_allocate);
  rb_define_method(cAllocSettlInstType.klass, "initialize", VALUEFUNC(_wrap_new_AllocSettlInstType), -1);
  cAllocSettlInstType.mark = 0;
  cAllocSettlInstType.destroy = (void (*)(void *)) free_FIX_AllocSettlInstType;
  cAllocSettlInstType.trackObjects = 0;
  
  cTargetPartyID.klass = rb_define_class_under(mQuickfix, "TargetPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetPartyID, (void *) &cTargetPartyID);
  rb_define_alloc_func(cTargetPartyID.klass, _wrap_TargetPartyID_allocate);
  rb_define_method(cTargetPartyID.klass, "initialize", VALUEFUNC(_wrap_new_TargetPartyID), -1);
  cTargetPartyID.mark = 0;
  cTargetPartyID.destroy = (void (*)(void *)) free_FIX_TargetPartyID;
  cTargetPartyID.trackObjects = 0;
  
  cDerivativeStrikeCurrency.klass = rb_define_class_under(mQuickfix, "DerivativeStrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikeCurrency, (void *) &cDerivativeStrikeCurrency);
  rb_define_alloc_func(cDerivativeStrikeCurrency.klass, _wrap_DerivativeStrikeCurrency_allocate);
  rb_define_method(cDerivativeStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikeCurrency), -1);
  cDerivativeStrikeCurrency.mark = 0;
  cDerivativeStrikeCurrency.destroy = (void (*)(void *)) free_FIX_DerivativeStrikeCurrency;
  cDerivativeStrikeCurrency.trackObjects = 0;
  
  cStatsType.klass = rb_define_class_under(mQuickfix, "StatsType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StatsType, (void *) &cStatsType);
  rb_define_alloc_func(cStatsType.klass, _wrap_StatsType_allocate);
  rb_define_method(cStatsType.klass, "initialize", VALUEFUNC(_wrap_new_StatsType), -1);
  cStatsType.mark = 0;
  cStatsType.destroy = (void (*)(void *)) free_FIX_StatsType;
  cStatsType.trackObjects = 0;
  
  cApplExtID.klass = rb_define_class_under(mQuickfix, "ApplExtID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplExtID, (void *) &cApplExtID);
  rb_define_alloc_func(cApplExtID.klass, _wrap_ApplExtID_allocate);
  rb_define_method(cApplExtID.klass, "initialize", VALUEFUNC(_wrap_new_ApplExtID), -1);
  cApplExtID.mark = 0;
  cApplExtID.destroy = (void (*)(void *)) free_FIX_ApplExtID;
  cApplExtID.trackObjects = 0;
  
  cSettlementCycleNo.klass = rb_define_class_under(mQuickfix, "SettlementCycleNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlementCycleNo, (void *) &cSettlementCycleNo);
  rb_define_alloc_func(cSettlementCycleNo.klass, _wrap_SettlementCycleNo_allocate);
  rb_define_method(cSettlementCycleNo.klass, "initialize", VALUEFUNC(_wrap_new_SettlementCycleNo), -1);
  cSettlementCycleNo.mark = 0;
  cSettlementCycleNo.destroy = (void (*)(void *)) free_FIX_SettlementCycleNo;
  cSettlementCycleNo.trackObjects = 0;
  
  cUnderlyingStrikeCurrency.klass = rb_define_class_under(mQuickfix, "UnderlyingStrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStrikeCurrency, (void *) &cUnderlyingStrikeCurrency);
  rb_define_alloc_func(cUnderlyingStrikeCurrency.klass, _wrap_UnderlyingStrikeCurrency_allocate);
  rb_define_method(cUnderlyingStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStrikeCurrency), -1);
  cUnderlyingStrikeCurrency.mark = 0;
  cUnderlyingStrikeCurrency.destroy = (void (*)(void *)) free_FIX_UnderlyingStrikeCurrency;
  cUnderlyingStrikeCurrency.trackObjects = 0;
  
  cTradSesMode.klass = rb_define_class_under(mQuickfix, "TradSesMode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesMode, (void *) &cTradSesMode);
  rb_define_alloc_func(cTradSesMode.klass, _wrap_TradSesMode_allocate);
  rb_define_method(cTradSesMode.klass, "initialize", VALUEFUNC(_wrap_new_TradSesMode), -1);
  cTradSesMode.mark = 0;
  cTradSesMode.destroy = (void (*)(void *)) free_FIX_TradSesMode;
  cTradSesMode.trackObjects = 0;
  
  cSettlInstSource.klass = rb_define_class_under(mQuickfix, "SettlInstSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstSource, (void *) &cSettlInstSource);
  rb_define_alloc_func(cSettlInstSource.klass, _wrap_SettlInstSource_allocate);
  rb_define_method(cSettlInstSource.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstSource), -1);
  cSettlInstSource.mark = 0;
  cSettlInstSource.destroy = (void (*)(void *)) free_FIX_SettlInstSource;
  cSettlInstSource.trackObjects = 0;
  
  cPartyAltSubIDType.klass = rb_define_class_under(mQuickfix, "PartyAltSubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyAltSubIDType, (void *) &cPartyAltSubIDType);
  rb_define_alloc_func(cPartyAltSubIDType.klass, _wrap_PartyAltSubIDType_allocate);
  rb_define_method(cPartyAltSubIDType.klass, "initialize", VALUEFUNC(_wrap_new_PartyAltSubIDType), -1);
  cPartyAltSubIDType.mark = 0;
  cPartyAltSubIDType.destroy = (void (*)(void *)) free_FIX_PartyAltSubIDType;
  cPartyAltSubIDType.trackObjects = 0;
  
  cUnderlyingLegSecurityDesc.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityDesc, (void *) &cUnderlyingLegSecurityDesc);
  rb_define_alloc_func(cUnderlyingLegSecurityDesc.klass, _wrap_UnderlyingLegSecurityDesc_allocate);
  rb_define_method(cUnderlyingLegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityDesc), -1);
  cUnderlyingLegSecurityDesc.mark = 0;
  cUnderlyingLegSecurityDesc.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityDesc;
  cUnderlyingLegSecurityDesc.trackObjects = 0;
  
  cNoDerivativeInstrumentParties.klass = rb_define_class_under(mQuickfix, "NoDerivativeInstrumentParties", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeInstrumentParties, (void *) &cNoDerivativeInstrumentParties);
  rb_define_alloc_func(cNoDerivativeInstrumentParties.klass, _wrap_NoDerivativeInstrumentParties_allocate);
  rb_define_method(cNoDerivativeInstrumentParties.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeInstrumentParties), -1);
  cNoDerivativeInstrumentParties.mark = 0;
  cNoDerivativeInstrumentParties.destroy = (void (*)(void *)) free_FIX_NoDerivativeInstrumentParties;
  cNoDerivativeInstrumentParties.trackObjects = 0;
  
  cDerivativeEventTime.klass = rb_define_class_under(mQuickfix, "DerivativeEventTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventTime, (void *) &cDerivativeEventTime);
  rb_define_alloc_func(cDerivativeEventTime.klass, _wrap_DerivativeEventTime_allocate);
  rb_define_method(cDerivativeEventTime.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventTime), -1);
  cDerivativeEventTime.mark = 0;
  cDerivativeEventTime.destroy = (void (*)(void *)) free_FIX_DerivativeEventTime;
  cDerivativeEventTime.trackObjects = 0;
  
  cTickIncrement.klass = rb_define_class_under(mQuickfix, "TickIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TickIncrement, (void *) &cTickIncrement);
  rb_define_alloc_func(cTickIncrement.klass, _wrap_TickIncrement_allocate);
  rb_define_method(cTickIncrement.klass, "initialize", VALUEFUNC(_wrap_new_TickIncrement), -1);
  cTickIncrement.mark = 0;
  cTickIncrement.destroy = (void (*)(void *)) free_FIX_TickIncrement;
  cTickIncrement.trackObjects = 0;
  
  cUndlyInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartyID, (void *) &cUndlyInstrumentPartyID);
  rb_define_alloc_func(cUndlyInstrumentPartyID.klass, _wrap_UndlyInstrumentPartyID_allocate);
  rb_define_method(cUndlyInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartyID), -1);
  cUndlyInstrumentPartyID.mark = 0;
  cUndlyInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartyID;
  cUndlyInstrumentPartyID.trackObjects = 0;
  
  cNoUndlyInstrumentParties.klass = rb_define_class_under(mQuickfix, "NoUndlyInstrumentParties", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUndlyInstrumentParties, (void *) &cNoUndlyInstrumentParties);
  rb_define_alloc_func(cNoUndlyInstrumentParties.klass, _wrap_NoUndlyInstrumentParties_allocate);
  rb_define_method(cNoUndlyInstrumentParties.klass, "initialize", VALUEFUNC(_wrap_new_NoUndlyInstrumentParties), -1);
  cNoUndlyInstrumentParties.mark = 0;
  cNoUndlyInstrumentParties.destroy = (void (*)(void *)) free_FIX_NoUndlyInstrumentParties;
  cNoUndlyInstrumentParties.trackObjects = 0;
  
  cExpType.klass = rb_define_class_under(mQuickfix, "ExpType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpType, (void *) &cExpType);
  rb_define_alloc_func(cExpType.klass, _wrap_ExpType_allocate);
  rb_define_method(cExpType.klass, "initialize", VALUEFUNC(_wrap_new_ExpType), -1);
  cExpType.mark = 0;
  cExpType.destroy = (void (*)(void *)) free_FIX_ExpType;
  cExpType.trackObjects = 0;
  
  cSecondaryClOrdID.klass = rb_define_class_under(mQuickfix, "SecondaryClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryClOrdID, (void *) &cSecondaryClOrdID);
  rb_define_alloc_func(cSecondaryClOrdID.klass, _wrap_SecondaryClOrdID_allocate);
  rb_define_method(cSecondaryClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryClOrdID), -1);
  cSecondaryClOrdID.mark = 0;
  cSecondaryClOrdID.destroy = (void (*)(void *)) free_FIX_SecondaryClOrdID;
  cSecondaryClOrdID.trackObjects = 0;
  
  cSettlInstTransType.klass = rb_define_class_under(mQuickfix, "SettlInstTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstTransType, (void *) &cSettlInstTransType);
  rb_define_alloc_func(cSettlInstTransType.klass, _wrap_SettlInstTransType_allocate);
  rb_define_method(cSettlInstTransType.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstTransType), -1);
  cSettlInstTransType.mark = 0;
  cSettlInstTransType.destroy = (void (*)(void *)) free_FIX_SettlInstTransType;
  cSettlInstTransType.trackObjects = 0;
  
  cSideComplianceID.klass = rb_define_class_under(mQuickfix, "SideComplianceID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideComplianceID, (void *) &cSideComplianceID);
  rb_define_alloc_func(cSideComplianceID.klass, _wrap_SideComplianceID_allocate);
  rb_define_method(cSideComplianceID.klass, "initialize", VALUEFUNC(_wrap_new_SideComplianceID), -1);
  cSideComplianceID.mark = 0;
  cSideComplianceID.destroy = (void (*)(void *)) free_FIX_SideComplianceID;
  cSideComplianceID.trackObjects = 0;
  
  cTradeRequestResult.klass = rb_define_class_under(mQuickfix, "TradeRequestResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestResult, (void *) &cTradeRequestResult);
  rb_define_alloc_func(cTradeRequestResult.klass, _wrap_TradeRequestResult_allocate);
  rb_define_method(cTradeRequestResult.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestResult), -1);
  cTradeRequestResult.mark = 0;
  cTradeRequestResult.destroy = (void (*)(void *)) free_FIX_TradeRequestResult;
  cTradeRequestResult.trackObjects = 0;
  
  cOrigPosReqRefID.klass = rb_define_class_under(mQuickfix, "OrigPosReqRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigPosReqRefID, (void *) &cOrigPosReqRefID);
  rb_define_alloc_func(cOrigPosReqRefID.klass, _wrap_OrigPosReqRefID_allocate);
  rb_define_method(cOrigPosReqRefID.klass, "initialize", VALUEFUNC(_wrap_new_OrigPosReqRefID), -1);
  cOrigPosReqRefID.mark = 0;
  cOrigPosReqRefID.destroy = (void (*)(void *)) free_FIX_OrigPosReqRefID;
  cOrigPosReqRefID.trackObjects = 0;
  
  cOrigCrossID.klass = rb_define_class_under(mQuickfix, "OrigCrossID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigCrossID, (void *) &cOrigCrossID);
  rb_define_alloc_func(cOrigCrossID.klass, _wrap_OrigCrossID_allocate);
  rb_define_method(cOrigCrossID.klass, "initialize", VALUEFUNC(_wrap_new_OrigCrossID), -1);
  cOrigCrossID.mark = 0;
  cOrigCrossID.destroy = (void (*)(void *)) free_FIX_OrigCrossID;
  cOrigCrossID.trackObjects = 0;
  
  cTradeInputSource.klass = rb_define_class_under(mQuickfix, "TradeInputSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeInputSource, (void *) &cTradeInputSource);
  rb_define_alloc_func(cTradeInputSource.klass, _wrap_TradeInputSource_allocate);
  rb_define_method(cTradeInputSource.klass, "initialize", VALUEFUNC(_wrap_new_TradeInputSource), -1);
  cTradeInputSource.mark = 0;
  cTradeInputSource.destroy = (void (*)(void *)) free_FIX_TradeInputSource;
  cTradeInputSource.trackObjects = 0;
  
  cOrderQty2.klass = rb_define_class_under(mQuickfix, "OrderQty2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderQty2, (void *) &cOrderQty2);
  rb_define_alloc_func(cOrderQty2.klass, _wrap_OrderQty2_allocate);
  rb_define_method(cOrderQty2.klass, "initialize", VALUEFUNC(_wrap_new_OrderQty2), -1);
  cOrderQty2.mark = 0;
  cOrderQty2.destroy = (void (*)(void *)) free_FIX_OrderQty2;
  cOrderQty2.trackObjects = 0;
  
  cTestMessageIndicator.klass = rb_define_class_under(mQuickfix, "TestMessageIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TestMessageIndicator, (void *) &cTestMessageIndicator);
  rb_define_alloc_func(cTestMessageIndicator.klass, _wrap_TestMessageIndicator_allocate);
  rb_define_method(cTestMessageIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TestMessageIndicator), -1);
  cTestMessageIndicator.mark = 0;
  cTestMessageIndicator.destroy = (void (*)(void *)) free_FIX_TestMessageIndicator;
  cTestMessageIndicator.trackObjects = 0;
  
  cContextPartySubID.klass = rb_define_class_under(mQuickfix, "ContextPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContextPartySubID, (void *) &cContextPartySubID);
  rb_define_alloc_func(cContextPartySubID.klass, _wrap_ContextPartySubID_allocate);
  rb_define_method(cContextPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_ContextPartySubID), -1);
  cContextPartySubID.mark = 0;
  cContextPartySubID.destroy = (void (*)(void *)) free_FIX_ContextPartySubID;
  cContextPartySubID.trackObjects = 0;
  
  cDerivativeEventDate.klass = rb_define_class_under(mQuickfix, "DerivativeEventDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventDate, (void *) &cDerivativeEventDate);
  rb_define_alloc_func(cDerivativeEventDate.klass, _wrap_DerivativeEventDate_allocate);
  rb_define_method(cDerivativeEventDate.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventDate), -1);
  cDerivativeEventDate.mark = 0;
  cDerivativeEventDate.destroy = (void (*)(void *)) free_FIX_DerivativeEventDate;
  cDerivativeEventDate.trackObjects = 0;
  
  cSideGrossTradeAmt.klass = rb_define_class_under(mQuickfix, "SideGrossTradeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideGrossTradeAmt, (void *) &cSideGrossTradeAmt);
  rb_define_alloc_func(cSideGrossTradeAmt.klass, _wrap_SideGrossTradeAmt_allocate);
  rb_define_method(cSideGrossTradeAmt.klass, "initialize", VALUEFUNC(_wrap_new_SideGrossTradeAmt), -1);
  cSideGrossTradeAmt.mark = 0;
  cSideGrossTradeAmt.destroy = (void (*)(void *)) free_FIX_SideGrossTradeAmt;
  cSideGrossTradeAmt.trackObjects = 0;
  
  cPeggedPrice.klass = rb_define_class_under(mQuickfix, "PeggedPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PeggedPrice, (void *) &cPeggedPrice);
  rb_define_alloc_func(cPeggedPrice.klass, _wrap_PeggedPrice_allocate);
  rb_define_method(cPeggedPrice.klass, "initialize", VALUEFUNC(_wrap_new_PeggedPrice), -1);
  cPeggedPrice.mark = 0;
  cPeggedPrice.destroy = (void (*)(void *)) free_FIX_PeggedPrice;
  cPeggedPrice.trackObjects = 0;
  
  cExpirationCycle.klass = rb_define_class_under(mQuickfix, "ExpirationCycle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpirationCycle, (void *) &cExpirationCycle);
  rb_define_alloc_func(cExpirationCycle.klass, _wrap_ExpirationCycle_allocate);
  rb_define_method(cExpirationCycle.klass, "initialize", VALUEFUNC(_wrap_new_ExpirationCycle), -1);
  cExpirationCycle.mark = 0;
  cExpirationCycle.destroy = (void (*)(void *)) free_FIX_ExpirationCycle;
  cExpirationCycle.trackObjects = 0;
  
  cAllocCancReplaceReason.klass = rb_define_class_under(mQuickfix, "AllocCancReplaceReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocCancReplaceReason, (void *) &cAllocCancReplaceReason);
  rb_define_alloc_func(cAllocCancReplaceReason.klass, _wrap_AllocCancReplaceReason_allocate);
  rb_define_method(cAllocCancReplaceReason.klass, "initialize", VALUEFUNC(_wrap_new_AllocCancReplaceReason), -1);
  cAllocCancReplaceReason.mark = 0;
  cAllocCancReplaceReason.destroy = (void (*)(void *)) free_FIX_AllocCancReplaceReason;
  cAllocCancReplaceReason.trackObjects = 0;
  
  cCxlRejReason.klass = rb_define_class_under(mQuickfix, "CxlRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlRejReason, (void *) &cCxlRejReason);
  rb_define_alloc_func(cCxlRejReason.klass, _wrap_CxlRejReason_allocate);
  rb_define_method(cCxlRejReason.klass, "initialize", VALUEFUNC(_wrap_new_CxlRejReason), -1);
  cCxlRejReason.mark = 0;
  cCxlRejReason.destroy = (void (*)(void *)) free_FIX_CxlRejReason;
  cCxlRejReason.trackObjects = 0;
  
  cBeginString.klass = rb_define_class_under(mQuickfix, "BeginString", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BeginString, (void *) &cBeginString);
  rb_define_alloc_func(cBeginString.klass, _wrap_BeginString_allocate);
  rb_define_method(cBeginString.klass, "initialize", VALUEFUNC(_wrap_new_BeginString), -1);
  cBeginString.mark = 0;
  cBeginString.destroy = (void (*)(void *)) free_FIX_BeginString;
  cBeginString.trackObjects = 0;
  
  cDeliverToSubID.klass = rb_define_class_under(mQuickfix, "DeliverToSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliverToSubID, (void *) &cDeliverToSubID);
  rb_define_alloc_func(cDeliverToSubID.klass, _wrap_DeliverToSubID_allocate);
  rb_define_method(cDeliverToSubID.klass, "initialize", VALUEFUNC(_wrap_new_DeliverToSubID), -1);
  cDeliverToSubID.mark = 0;
  cDeliverToSubID.destroy = (void (*)(void *)) free_FIX_DeliverToSubID;
  cDeliverToSubID.trackObjects = 0;
  
  cNoRelatedPartyAltIDs.klass = rb_define_class_under(mQuickfix, "NoRelatedPartyAltIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedPartyAltIDs, (void *) &cNoRelatedPartyAltIDs);
  rb_define_alloc_func(cNoRelatedPartyAltIDs.klass, _wrap_NoRelatedPartyAltIDs_allocate);
  rb_define_method(cNoRelatedPartyAltIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedPartyAltIDs), -1);
  cNoRelatedPartyAltIDs.mark = 0;
  cNoRelatedPartyAltIDs.destroy = (void (*)(void *)) free_FIX_NoRelatedPartyAltIDs;
  cNoRelatedPartyAltIDs.trackObjects = 0;
  
  cRiskProductComplex.klass = rb_define_class_under(mQuickfix, "RiskProductComplex", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskProductComplex, (void *) &cRiskProductComplex);
  rb_define_alloc_func(cRiskProductComplex.klass, _wrap_RiskProductComplex_allocate);
  rb_define_method(cRiskProductComplex.klass, "initialize", VALUEFUNC(_wrap_new_RiskProductComplex), -1);
  cRiskProductComplex.mark = 0;
  cRiskProductComplex.destroy = (void (*)(void *)) free_FIX_RiskProductComplex;
  cRiskProductComplex.trackObjects = 0;
  
  cLegPriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "LegPriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPriceUnitOfMeasureQty, (void *) &cLegPriceUnitOfMeasureQty);
  rb_define_alloc_func(cLegPriceUnitOfMeasureQty.klass, _wrap_LegPriceUnitOfMeasureQty_allocate);
  rb_define_method(cLegPriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_LegPriceUnitOfMeasureQty), -1);
  cLegPriceUnitOfMeasureQty.mark = 0;
  cLegPriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_LegPriceUnitOfMeasureQty;
  cLegPriceUnitOfMeasureQty.trackObjects = 0;
  
  cNoCollInquiryQualifier.klass = rb_define_class_under(mQuickfix, "NoCollInquiryQualifier", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoCollInquiryQualifier, (void *) &cNoCollInquiryQualifier);
  rb_define_alloc_func(cNoCollInquiryQualifier.klass, _wrap_NoCollInquiryQualifier_allocate);
  rb_define_method(cNoCollInquiryQualifier.klass, "initialize", VALUEFUNC(_wrap_new_NoCollInquiryQualifier), -1);
  cNoCollInquiryQualifier.mark = 0;
  cNoCollInquiryQualifier.destroy = (void (*)(void *)) free_FIX_NoCollInquiryQualifier;
  cNoCollInquiryQualifier.trackObjects = 0;
  
  cOfferPx.klass = rb_define_class_under(mQuickfix, "OfferPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferPx, (void *) &cOfferPx);
  rb_define_alloc_func(cOfferPx.klass, _wrap_OfferPx_allocate);
  rb_define_method(cOfferPx.klass, "initialize", VALUEFUNC(_wrap_new_OfferPx), -1);
  cOfferPx.mark = 0;
  cOfferPx.destroy = (void (*)(void *)) free_FIX_OfferPx;
  cOfferPx.trackObjects = 0;
  
  cTotalVolumeTradedDate.klass = rb_define_class_under(mQuickfix, "TotalVolumeTradedDate", ((swig_class *) SWIGTYPE_p_FIX__UtcDateField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalVolumeTradedDate, (void *) &cTotalVolumeTradedDate);
  rb_define_alloc_func(cTotalVolumeTradedDate.klass, _wrap_TotalVolumeTradedDate_allocate);
  rb_define_method(cTotalVolumeTradedDate.klass, "initialize", VALUEFUNC(_wrap_new_TotalVolumeTradedDate), -1);
  cTotalVolumeTradedDate.mark = 0;
  cTotalVolumeTradedDate.destroy = (void (*)(void *)) free_FIX_TotalVolumeTradedDate;
  cTotalVolumeTradedDate.trackObjects = 0;
  
  cNoContAmts.klass = rb_define_class_under(mQuickfix, "NoContAmts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoContAmts, (void *) &cNoContAmts);
  rb_define_alloc_func(cNoContAmts.klass, _wrap_NoContAmts_allocate);
  rb_define_method(cNoContAmts.klass, "initialize", VALUEFUNC(_wrap_new_NoContAmts), -1);
  cNoContAmts.mark = 0;
  cNoContAmts.destroy = (void (*)(void *)) free_FIX_NoContAmts;
  cNoContAmts.trackObjects = 0;
  
  cMinOfferSize.klass = rb_define_class_under(mQuickfix, "MinOfferSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinOfferSize, (void *) &cMinOfferSize);
  rb_define_alloc_func(cMinOfferSize.klass, _wrap_MinOfferSize_allocate);
  rb_define_method(cMinOfferSize.klass, "initialize", VALUEFUNC(_wrap_new_MinOfferSize), -1);
  cMinOfferSize.mark = 0;
  cMinOfferSize.destroy = (void (*)(void *)) free_FIX_MinOfferSize;
  cMinOfferSize.trackObjects = 0;
  
  cAvgParPx.klass = rb_define_class_under(mQuickfix, "AvgParPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgParPx, (void *) &cAvgParPx);
  rb_define_alloc_func(cAvgParPx.klass, _wrap_AvgParPx_allocate);
  rb_define_method(cAvgParPx.klass, "initialize", VALUEFUNC(_wrap_new_AvgParPx), -1);
  cAvgParPx.mark = 0;
  cAvgParPx.destroy = (void (*)(void *)) free_FIX_AvgParPx;
  cAvgParPx.trackObjects = 0;
  
  cLegFactor.klass = rb_define_class_under(mQuickfix, "LegFactor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegFactor, (void *) &cLegFactor);
  rb_define_alloc_func(cLegFactor.klass, _wrap_LegFactor_allocate);
  rb_define_method(cLegFactor.klass, "initialize", VALUEFUNC(_wrap_new_LegFactor), -1);
  cLegFactor.mark = 0;
  cLegFactor.destroy = (void (*)(void *)) free_FIX_LegFactor;
  cLegFactor.trackObjects = 0;
  
  cRespondentType.klass = rb_define_class_under(mQuickfix, "RespondentType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RespondentType, (void *) &cRespondentType);
  rb_define_alloc_func(cRespondentType.klass, _wrap_RespondentType_allocate);
  rb_define_method(cRespondentType.klass, "initialize", VALUEFUNC(_wrap_new_RespondentType), -1);
  cRespondentType.mark = 0;
  cRespondentType.destroy = (void (*)(void *)) free_FIX_RespondentType;
  cRespondentType.trackObjects = 0;
  
  cDisplayLowQty.klass = rb_define_class_under(mQuickfix, "DisplayLowQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayLowQty, (void *) &cDisplayLowQty);
  rb_define_alloc_func(cDisplayLowQty.klass, _wrap_DisplayLowQty_allocate);
  rb_define_method(cDisplayLowQty.klass, "initialize", VALUEFUNC(_wrap_new_DisplayLowQty), -1);
  cDisplayLowQty.mark = 0;
  cDisplayLowQty.destroy = (void (*)(void *)) free_FIX_DisplayLowQty;
  cDisplayLowQty.trackObjects = 0;
  
  cDKReason.klass = rb_define_class_under(mQuickfix, "DKReason", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DKReason, (void *) &cDKReason);
  rb_define_alloc_func(cDKReason.klass, _wrap_DKReason_allocate);
  rb_define_method(cDKReason.klass, "initialize", VALUEFUNC(_wrap_new_DKReason), -1);
  cDKReason.mark = 0;
  cDKReason.destroy = (void (*)(void *)) free_FIX_DKReason;
  cDKReason.trackObjects = 0;
  
  cBenchmarkPrice.klass = rb_define_class_under(mQuickfix, "BenchmarkPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkPrice, (void *) &cBenchmarkPrice);
  rb_define_alloc_func(cBenchmarkPrice.klass, _wrap_BenchmarkPrice_allocate);
  rb_define_method(cBenchmarkPrice.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkPrice), -1);
  cBenchmarkPrice.mark = 0;
  cBenchmarkPrice.destroy = (void (*)(void *)) free_FIX_BenchmarkPrice;
  cBenchmarkPrice.trackObjects = 0;
  
  cListID.klass = rb_define_class_under(mQuickfix, "ListID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListID, (void *) &cListID);
  rb_define_alloc_func(cListID.klass, _wrap_ListID_allocate);
  rb_define_method(cListID.klass, "initialize", VALUEFUNC(_wrap_new_ListID), -1);
  cListID.mark = 0;
  cListID.destroy = (void (*)(void *)) free_FIX_ListID;
  cListID.trackObjects = 0;
  
  cLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "LegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityAltID, (void *) &cLegSecurityAltID);
  rb_define_alloc_func(cLegSecurityAltID.klass, _wrap_LegSecurityAltID_allocate);
  rb_define_method(cLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityAltID), -1);
  cLegSecurityAltID.mark = 0;
  cLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_LegSecurityAltID;
  cLegSecurityAltID.trackObjects = 0;
  
  cPositionEffect.klass = rb_define_class_under(mQuickfix, "PositionEffect", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PositionEffect, (void *) &cPositionEffect);
  rb_define_alloc_func(cPositionEffect.klass, _wrap_PositionEffect_allocate);
  rb_define_method(cPositionEffect.klass, "initialize", VALUEFUNC(_wrap_new_PositionEffect), -1);
  cPositionEffect.mark = 0;
  cPositionEffect.destroy = (void (*)(void *)) free_FIX_PositionEffect;
  cPositionEffect.trackObjects = 0;
  
  cRelatedPartySubIDType.klass = rb_define_class_under(mQuickfix, "RelatedPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartySubIDType, (void *) &cRelatedPartySubIDType);
  rb_define_alloc_func(cRelatedPartySubIDType.klass, _wrap_RelatedPartySubIDType_allocate);
  rb_define_method(cRelatedPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartySubIDType), -1);
  cRelatedPartySubIDType.mark = 0;
  cRelatedPartySubIDType.destroy = (void (*)(void *)) free_FIX_RelatedPartySubIDType;
  cRelatedPartySubIDType.trackObjects = 0;
  
  cTriggerAction.klass = rb_define_class_under(mQuickfix, "TriggerAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerAction, (void *) &cTriggerAction);
  rb_define_alloc_func(cTriggerAction.klass, _wrap_TriggerAction_allocate);
  rb_define_method(cTriggerAction.klass, "initialize", VALUEFUNC(_wrap_new_TriggerAction), -1);
  cTriggerAction.mark = 0;
  cTriggerAction.destroy = (void (*)(void *)) free_FIX_TriggerAction;
  cTriggerAction.trackObjects = 0;
  
  cRefOrderID.klass = rb_define_class_under(mQuickfix, "RefOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefOrderID, (void *) &cRefOrderID);
  rb_define_alloc_func(cRefOrderID.klass, _wrap_RefOrderID_allocate);
  rb_define_method(cRefOrderID.klass, "initialize", VALUEFUNC(_wrap_new_RefOrderID), -1);
  cRefOrderID.mark = 0;
  cRefOrderID.destroy = (void (*)(void *)) free_FIX_RefOrderID;
  cRefOrderID.trackObjects = 0;
  
  cClearingInstruction.klass = rb_define_class_under(mQuickfix, "ClearingInstruction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingInstruction, (void *) &cClearingInstruction);
  rb_define_alloc_func(cClearingInstruction.klass, _wrap_ClearingInstruction_allocate);
  rb_define_method(cClearingInstruction.klass, "initialize", VALUEFUNC(_wrap_new_ClearingInstruction), -1);
  cClearingInstruction.mark = 0;
  cClearingInstruction.destroy = (void (*)(void *)) free_FIX_ClearingInstruction;
  cClearingInstruction.trackObjects = 0;
  
  cSettlInstCode.klass = rb_define_class_under(mQuickfix, "SettlInstCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstCode, (void *) &cSettlInstCode);
  rb_define_alloc_func(cSettlInstCode.klass, _wrap_SettlInstCode_allocate);
  rb_define_method(cSettlInstCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstCode), -1);
  cSettlInstCode.mark = 0;
  cSettlInstCode.destroy = (void (*)(void *)) free_FIX_SettlInstCode;
  cSettlInstCode.trackObjects = 0;
  
  cNumDaysInterest.klass = rb_define_class_under(mQuickfix, "NumDaysInterest", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumDaysInterest, (void *) &cNumDaysInterest);
  rb_define_alloc_func(cNumDaysInterest.klass, _wrap_NumDaysInterest_allocate);
  rb_define_method(cNumDaysInterest.klass, "initialize", VALUEFUNC(_wrap_new_NumDaysInterest), -1);
  cNumDaysInterest.mark = 0;
  cNumDaysInterest.destroy = (void (*)(void *)) free_FIX_NumDaysInterest;
  cNumDaysInterest.trackObjects = 0;
  
  cOpenCloseSettlFlag.klass = rb_define_class_under(mQuickfix, "OpenCloseSettlFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenCloseSettlFlag, (void *) &cOpenCloseSettlFlag);
  rb_define_alloc_func(cOpenCloseSettlFlag.klass, _wrap_OpenCloseSettlFlag_allocate);
  rb_define_method(cOpenCloseSettlFlag.klass, "initialize", VALUEFUNC(_wrap_new_OpenCloseSettlFlag), -1);
  cOpenCloseSettlFlag.mark = 0;
  cOpenCloseSettlFlag.destroy = (void (*)(void *)) free_FIX_OpenCloseSettlFlag;
  cOpenCloseSettlFlag.trackObjects = 0;
  
  cNoComplexEventDates.klass = rb_define_class_under(mQuickfix, "NoComplexEventDates", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoComplexEventDates, (void *) &cNoComplexEventDates);
  rb_define_alloc_func(cNoComplexEventDates.klass, _wrap_NoComplexEventDates_allocate);
  rb_define_method(cNoComplexEventDates.klass, "initialize", VALUEFUNC(_wrap_new_NoComplexEventDates), -1);
  cNoComplexEventDates.mark = 0;
  cNoComplexEventDates.destroy = (void (*)(void *)) free_FIX_NoComplexEventDates;
  cNoComplexEventDates.trackObjects = 0;
  
  cDerivativeEncodedIssuerLen.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedIssuerLen, (void *) &cDerivativeEncodedIssuerLen);
  rb_define_alloc_func(cDerivativeEncodedIssuerLen.klass, _wrap_DerivativeEncodedIssuerLen_allocate);
  rb_define_method(cDerivativeEncodedIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedIssuerLen), -1);
  cDerivativeEncodedIssuerLen.mark = 0;
  cDerivativeEncodedIssuerLen.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedIssuerLen;
  cDerivativeEncodedIssuerLen.trackObjects = 0;
  
  cStrikeMultiplier.klass = rb_define_class_under(mQuickfix, "StrikeMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeMultiplier, (void *) &cStrikeMultiplier);
  rb_define_alloc_func(cStrikeMultiplier.klass, _wrap_StrikeMultiplier_allocate);
  rb_define_method(cStrikeMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_StrikeMultiplier), -1);
  cStrikeMultiplier.mark = 0;
  cStrikeMultiplier.destroy = (void (*)(void *)) free_FIX_StrikeMultiplier;
  cStrikeMultiplier.trackObjects = 0;
  
  cDiscretionMoveType.klass = rb_define_class_under(mQuickfix, "DiscretionMoveType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionMoveType, (void *) &cDiscretionMoveType);
  rb_define_alloc_func(cDiscretionMoveType.klass, _wrap_DiscretionMoveType_allocate);
  rb_define_method(cDiscretionMoveType.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionMoveType), -1);
  cDiscretionMoveType.mark = 0;
  cDiscretionMoveType.destroy = (void (*)(void *)) free_FIX_DiscretionMoveType;
  cDiscretionMoveType.trackObjects = 0;
  
  cListNoOrds.klass = rb_define_class_under(mQuickfix, "ListNoOrds", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListNoOrds, (void *) &cListNoOrds);
  rb_define_alloc_func(cListNoOrds.klass, _wrap_ListNoOrds_allocate);
  rb_define_method(cListNoOrds.klass, "initialize", VALUEFUNC(_wrap_new_ListNoOrds), -1);
  cListNoOrds.mark = 0;
  cListNoOrds.destroy = (void (*)(void *)) free_FIX_ListNoOrds;
  cListNoOrds.trackObjects = 0;
  
  cRelatedPartyIDSource.klass = rb_define_class_under(mQuickfix, "RelatedPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartyIDSource, (void *) &cRelatedPartyIDSource);
  rb_define_alloc_func(cRelatedPartyIDSource.klass, _wrap_RelatedPartyIDSource_allocate);
  rb_define_method(cRelatedPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartyIDSource), -1);
  cRelatedPartyIDSource.mark = 0;
  cRelatedPartyIDSource.destroy = (void (*)(void *)) free_FIX_RelatedPartyIDSource;
  cRelatedPartyIDSource.trackObjects = 0;
  
  cPegSymbol.klass = rb_define_class_under(mQuickfix, "PegSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSymbol, (void *) &cPegSymbol);
  rb_define_alloc_func(cPegSymbol.klass, _wrap_PegSymbol_allocate);
  rb_define_method(cPegSymbol.klass, "initialize", VALUEFUNC(_wrap_new_PegSymbol), -1);
  cPegSymbol.mark = 0;
  cPegSymbol.destroy = (void (*)(void *)) free_FIX_PegSymbol;
  cPegSymbol.trackObjects = 0;
  
  cDayAvgPx.klass = rb_define_class_under(mQuickfix, "DayAvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayAvgPx, (void *) &cDayAvgPx);
  rb_define_alloc_func(cDayAvgPx.klass, _wrap_DayAvgPx_allocate);
  rb_define_method(cDayAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_DayAvgPx), -1);
  cDayAvgPx.mark = 0;
  cDayAvgPx.destroy = (void (*)(void *)) free_FIX_DayAvgPx;
  cDayAvgPx.trackObjects = 0;
  
  cHeadline.klass = rb_define_class_under(mQuickfix, "Headline", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Headline, (void *) &cHeadline);
  rb_define_alloc_func(cHeadline.klass, _wrap_Headline_allocate);
  rb_define_method(cHeadline.klass, "initialize", VALUEFUNC(_wrap_new_Headline), -1);
  cHeadline.mark = 0;
  cHeadline.destroy = (void (*)(void *)) free_FIX_Headline;
  cHeadline.trackObjects = 0;
  
  cNestedPartySubID.klass = rb_define_class_under(mQuickfix, "NestedPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartySubID, (void *) &cNestedPartySubID);
  rb_define_alloc_func(cNestedPartySubID.klass, _wrap_NestedPartySubID_allocate);
  rb_define_method(cNestedPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartySubID), -1);
  cNestedPartySubID.mark = 0;
  cNestedPartySubID.destroy = (void (*)(void *)) free_FIX_NestedPartySubID;
  cNestedPartySubID.trackObjects = 0;
  
  cCardIssNo.klass = rb_define_class_under(mQuickfix, "CardIssNo", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardIssNo, (void *) &cCardIssNo);
  rb_define_alloc_func(cCardIssNo.klass, _wrap_CardIssNo_allocate);
  rb_define_method(cCardIssNo.klass, "initialize", VALUEFUNC(_wrap_new_CardIssNo), -1);
  cCardIssNo.mark = 0;
  cCardIssNo.destroy = (void (*)(void *)) free_FIX_CardIssNo;
  cCardIssNo.trackObjects = 0;
  
  cOptAttribute.klass = rb_define_class_under(mQuickfix, "OptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptAttribute, (void *) &cOptAttribute);
  rb_define_alloc_func(cOptAttribute.klass, _wrap_OptAttribute_allocate);
  rb_define_method(cOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_OptAttribute), -1);
  cOptAttribute.mark = 0;
  cOptAttribute.destroy = (void (*)(void *)) free_FIX_OptAttribute;
  cOptAttribute.trackObjects = 0;
  
  cLastForwardPoints2.klass = rb_define_class_under(mQuickfix, "LastForwardPoints2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastForwardPoints2, (void *) &cLastForwardPoints2);
  rb_define_alloc_func(cLastForwardPoints2.klass, _wrap_LastForwardPoints2_allocate);
  rb_define_method(cLastForwardPoints2.klass, "initialize", VALUEFUNC(_wrap_new_LastForwardPoints2), -1);
  cLastForwardPoints2.mark = 0;
  cLastForwardPoints2.destroy = (void (*)(void *)) free_FIX_LastForwardPoints2;
  cLastForwardPoints2.trackObjects = 0;
  
  cMDUpdateType.klass = rb_define_class_under(mQuickfix, "MDUpdateType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDUpdateType, (void *) &cMDUpdateType);
  rb_define_alloc_func(cMDUpdateType.klass, _wrap_MDUpdateType_allocate);
  rb_define_method(cMDUpdateType.klass, "initialize", VALUEFUNC(_wrap_new_MDUpdateType), -1);
  cMDUpdateType.mark = 0;
  cMDUpdateType.destroy = (void (*)(void *)) free_FIX_MDUpdateType;
  cMDUpdateType.trackObjects = 0;
  
  cTickDirection.klass = rb_define_class_under(mQuickfix, "TickDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TickDirection, (void *) &cTickDirection);
  rb_define_alloc_func(cTickDirection.klass, _wrap_TickDirection_allocate);
  rb_define_method(cTickDirection.klass, "initialize", VALUEFUNC(_wrap_new_TickDirection), -1);
  cTickDirection.mark = 0;
  cTickDirection.destroy = (void (*)(void *)) free_FIX_TickDirection;
  cTickDirection.trackObjects = 0;
  
  cLegRedemptionDate.klass = rb_define_class_under(mQuickfix, "LegRedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRedemptionDate, (void *) &cLegRedemptionDate);
  rb_define_alloc_func(cLegRedemptionDate.klass, _wrap_LegRedemptionDate_allocate);
  rb_define_method(cLegRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_LegRedemptionDate), -1);
  cLegRedemptionDate.mark = 0;
  cLegRedemptionDate.destroy = (void (*)(void *)) free_FIX_LegRedemptionDate;
  cLegRedemptionDate.trackObjects = 0;
  
  cStrikePrice.klass = rb_define_class_under(mQuickfix, "StrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePrice, (void *) &cStrikePrice);
  rb_define_alloc_func(cStrikePrice.klass, _wrap_StrikePrice_allocate);
  rb_define_method(cStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_StrikePrice), -1);
  cStrikePrice.mark = 0;
  cStrikePrice.destroy = (void (*)(void *)) free_FIX_StrikePrice;
  cStrikePrice.trackObjects = 0;
  
  cEncodedIssuer.klass = rb_define_class_under(mQuickfix, "EncodedIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedIssuer, (void *) &cEncodedIssuer);
  rb_define_alloc_func(cEncodedIssuer.klass, _wrap_EncodedIssuer_allocate);
  rb_define_method(cEncodedIssuer.klass, "initialize", VALUEFUNC(_wrap_new_EncodedIssuer), -1);
  cEncodedIssuer.mark = 0;
  cEncodedIssuer.destroy = (void (*)(void *)) free_FIX_EncodedIssuer;
  cEncodedIssuer.trackObjects = 0;
  
  cYieldType.klass = rb_define_class_under(mQuickfix, "YieldType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldType, (void *) &cYieldType);
  rb_define_alloc_func(cYieldType.klass, _wrap_YieldType_allocate);
  rb_define_method(cYieldType.klass, "initialize", VALUEFUNC(_wrap_new_YieldType), -1);
  cYieldType.mark = 0;
  cYieldType.destroy = (void (*)(void *)) free_FIX_YieldType;
  cYieldType.trackObjects = 0;
  
  cTradingReferencePrice.klass = rb_define_class_under(mQuickfix, "TradingReferencePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingReferencePrice, (void *) &cTradingReferencePrice);
  rb_define_alloc_func(cTradingReferencePrice.klass, _wrap_TradingReferencePrice_allocate);
  rb_define_method(cTradingReferencePrice.klass, "initialize", VALUEFUNC(_wrap_new_TradingReferencePrice), -1);
  cTradingReferencePrice.mark = 0;
  cTradingReferencePrice.destroy = (void (*)(void *)) free_FIX_TradingReferencePrice;
  cTradingReferencePrice.trackObjects = 0;
  
  cMDEntrySpotRate.klass = rb_define_class_under(mQuickfix, "MDEntrySpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntrySpotRate, (void *) &cMDEntrySpotRate);
  rb_define_alloc_func(cMDEntrySpotRate.klass, _wrap_MDEntrySpotRate_allocate);
  rb_define_method(cMDEntrySpotRate.klass, "initialize", VALUEFUNC(_wrap_new_MDEntrySpotRate), -1);
  cMDEntrySpotRate.mark = 0;
  cMDEntrySpotRate.destroy = (void (*)(void *)) free_FIX_MDEntrySpotRate;
  cMDEntrySpotRate.trackObjects = 0;
  
  cParticipationRate.klass = rb_define_class_under(mQuickfix, "ParticipationRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ParticipationRate, (void *) &cParticipationRate);
  rb_define_alloc_func(cParticipationRate.klass, _wrap_ParticipationRate_allocate);
  rb_define_method(cParticipationRate.klass, "initialize", VALUEFUNC(_wrap_new_ParticipationRate), -1);
  cParticipationRate.mark = 0;
  cParticipationRate.destroy = (void (*)(void *)) free_FIX_ParticipationRate;
  cParticipationRate.trackObjects = 0;
  
  cPegScope.klass = rb_define_class_under(mQuickfix, "PegScope", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegScope, (void *) &cPegScope);
  rb_define_alloc_func(cPegScope.klass, _wrap_PegScope_allocate);
  rb_define_method(cPegScope.klass, "initialize", VALUEFUNC(_wrap_new_PegScope), -1);
  cPegScope.mark = 0;
  cPegScope.destroy = (void (*)(void *)) free_FIX_PegScope;
  cPegScope.trackObjects = 0;
  
  cInterestAtMaturity.klass = rb_define_class_under(mQuickfix, "InterestAtMaturity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InterestAtMaturity, (void *) &cInterestAtMaturity);
  rb_define_alloc_func(cInterestAtMaturity.klass, _wrap_InterestAtMaturity_allocate);
  rb_define_method(cInterestAtMaturity.klass, "initialize", VALUEFUNC(_wrap_new_InterestAtMaturity), -1);
  cInterestAtMaturity.mark = 0;
  cInterestAtMaturity.destroy = (void (*)(void *)) free_FIX_InterestAtMaturity;
  cInterestAtMaturity.trackObjects = 0;
  
  cLegIndividualAllocID.klass = rb_define_class_under(mQuickfix, "LegIndividualAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIndividualAllocID, (void *) &cLegIndividualAllocID);
  rb_define_alloc_func(cLegIndividualAllocID.klass, _wrap_LegIndividualAllocID_allocate);
  rb_define_method(cLegIndividualAllocID.klass, "initialize", VALUEFUNC(_wrap_new_LegIndividualAllocID), -1);
  cLegIndividualAllocID.mark = 0;
  cLegIndividualAllocID.destroy = (void (*)(void *)) free_FIX_LegIndividualAllocID;
  cLegIndividualAllocID.trackObjects = 0;
  
  cAllowableOneSidednessValue.klass = rb_define_class_under(mQuickfix, "AllowableOneSidednessValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllowableOneSidednessValue, (void *) &cAllowableOneSidednessValue);
  rb_define_alloc_func(cAllowableOneSidednessValue.klass, _wrap_AllowableOneSidednessValue_allocate);
  rb_define_method(cAllowableOneSidednessValue.klass, "initialize", VALUEFUNC(_wrap_new_AllowableOneSidednessValue), -1);
  cAllowableOneSidednessValue.mark = 0;
  cAllowableOneSidednessValue.destroy = (void (*)(void *)) free_FIX_AllowableOneSidednessValue;
  cAllowableOneSidednessValue.trackObjects = 0;
  
  cCashSettlAgentName.klass = rb_define_class_under(mQuickfix, "CashSettlAgentName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentName, (void *) &cCashSettlAgentName);
  rb_define_alloc_func(cCashSettlAgentName.klass, _wrap_CashSettlAgentName_allocate);
  rb_define_method(cCashSettlAgentName.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentName), -1);
  cCashSettlAgentName.mark = 0;
  cCashSettlAgentName.destroy = (void (*)(void *)) free_FIX_CashSettlAgentName;
  cCashSettlAgentName.trackObjects = 0;
  
  cContraTradeQty.klass = rb_define_class_under(mQuickfix, "ContraTradeQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraTradeQty, (void *) &cContraTradeQty);
  rb_define_alloc_func(cContraTradeQty.klass, _wrap_ContraTradeQty_allocate);
  rb_define_method(cContraTradeQty.klass, "initialize", VALUEFUNC(_wrap_new_ContraTradeQty), -1);
  cContraTradeQty.mark = 0;
  cContraTradeQty.destroy = (void (*)(void *)) free_FIX_ContraTradeQty;
  cContraTradeQty.trackObjects = 0;
  
  cLegMaturityTime.klass = rb_define_class_under(mQuickfix, "LegMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegMaturityTime, (void *) &cLegMaturityTime);
  rb_define_alloc_func(cLegMaturityTime.klass, _wrap_LegMaturityTime_allocate);
  rb_define_method(cLegMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_LegMaturityTime), -1);
  cLegMaturityTime.mark = 0;
  cLegMaturityTime.destroy = (void (*)(void *)) free_FIX_LegMaturityTime;
  cLegMaturityTime.trackObjects = 0;
  
  cSettlDeliveryType.klass = rb_define_class_under(mQuickfix, "SettlDeliveryType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDeliveryType, (void *) &cSettlDeliveryType);
  rb_define_alloc_func(cSettlDeliveryType.klass, _wrap_SettlDeliveryType_allocate);
  rb_define_method(cSettlDeliveryType.klass, "initialize", VALUEFUNC(_wrap_new_SettlDeliveryType), -1);
  cSettlDeliveryType.mark = 0;
  cSettlDeliveryType.destroy = (void (*)(void *)) free_FIX_SettlDeliveryType;
  cSettlDeliveryType.trackObjects = 0;
  
  cSecondaryPriceLimitType.klass = rb_define_class_under(mQuickfix, "SecondaryPriceLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryPriceLimitType, (void *) &cSecondaryPriceLimitType);
  rb_define_alloc_func(cSecondaryPriceLimitType.klass, _wrap_SecondaryPriceLimitType_allocate);
  rb_define_method(cSecondaryPriceLimitType.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryPriceLimitType), -1);
  cSecondaryPriceLimitType.mark = 0;
  cSecondaryPriceLimitType.destroy = (void (*)(void *)) free_FIX_SecondaryPriceLimitType;
  cSecondaryPriceLimitType.trackObjects = 0;
  
  cMidPx.klass = rb_define_class_under(mQuickfix, "MidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MidPx, (void *) &cMidPx);
  rb_define_alloc_func(cMidPx.klass, _wrap_MidPx_allocate);
  rb_define_method(cMidPx.klass, "initialize", VALUEFUNC(_wrap_new_MidPx), -1);
  cMidPx.mark = 0;
  cMidPx.destroy = (void (*)(void *)) free_FIX_MidPx;
  cMidPx.trackObjects = 0;
  
  cAvgPx.klass = rb_define_class_under(mQuickfix, "AvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPx, (void *) &cAvgPx);
  rb_define_alloc_func(cAvgPx.klass, _wrap_AvgPx_allocate);
  rb_define_method(cAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_AvgPx), -1);
  cAvgPx.mark = 0;
  cAvgPx.destroy = (void (*)(void *)) free_FIX_AvgPx;
  cAvgPx.trackObjects = 0;
  
  cDiscretionLimitType.klass = rb_define_class_under(mQuickfix, "DiscretionLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionLimitType, (void *) &cDiscretionLimitType);
  rb_define_alloc_func(cDiscretionLimitType.klass, _wrap_DiscretionLimitType_allocate);
  rb_define_method(cDiscretionLimitType.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionLimitType), -1);
  cDiscretionLimitType.mark = 0;
  cDiscretionLimitType.destroy = (void (*)(void *)) free_FIX_DiscretionLimitType;
  cDiscretionLimitType.trackObjects = 0;
  
  cStrikeTime.klass = rb_define_class_under(mQuickfix, "StrikeTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeTime, (void *) &cStrikeTime);
  rb_define_alloc_func(cStrikeTime.klass, _wrap_StrikeTime_allocate);
  rb_define_method(cStrikeTime.klass, "initialize", VALUEFUNC(_wrap_new_StrikeTime), -1);
  cStrikeTime.mark = 0;
  cStrikeTime.destroy = (void (*)(void *)) free_FIX_StrikeTime;
  cStrikeTime.trackObjects = 0;
  
  cSettlSessSubID.klass = rb_define_class_under(mQuickfix, "SettlSessSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlSessSubID, (void *) &cSettlSessSubID);
  rb_define_alloc_func(cSettlSessSubID.klass, _wrap_SettlSessSubID_allocate);
  rb_define_method(cSettlSessSubID.klass, "initialize", VALUEFUNC(_wrap_new_SettlSessSubID), -1);
  cSettlSessSubID.mark = 0;
  cSettlSessSubID.destroy = (void (*)(void *)) free_FIX_SettlSessSubID;
  cSettlSessSubID.trackObjects = 0;
  
  cMailingDtls.klass = rb_define_class_under(mQuickfix, "MailingDtls", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MailingDtls, (void *) &cMailingDtls);
  rb_define_alloc_func(cMailingDtls.klass, _wrap_MailingDtls_allocate);
  rb_define_method(cMailingDtls.klass, "initialize", VALUEFUNC(_wrap_new_MailingDtls), -1);
  cMailingDtls.mark = 0;
  cMailingDtls.destroy = (void (*)(void *)) free_FIX_MailingDtls;
  cMailingDtls.trackObjects = 0;
  
  cBidID.klass = rb_define_class_under(mQuickfix, "BidID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidID, (void *) &cBidID);
  rb_define_alloc_func(cBidID.klass, _wrap_BidID_allocate);
  rb_define_method(cBidID.klass, "initialize", VALUEFUNC(_wrap_new_BidID), -1);
  cBidID.mark = 0;
  cBidID.destroy = (void (*)(void *)) free_FIX_BidID;
  cBidID.trackObjects = 0;
  
  cPartyDetailsRequestResult.klass = rb_define_class_under(mQuickfix, "PartyDetailsRequestResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyDetailsRequestResult, (void *) &cPartyDetailsRequestResult);
  rb_define_alloc_func(cPartyDetailsRequestResult.klass, _wrap_PartyDetailsRequestResult_allocate);
  rb_define_method(cPartyDetailsRequestResult.klass, "initialize", VALUEFUNC(_wrap_new_PartyDetailsRequestResult), -1);
  cPartyDetailsRequestResult.mark = 0;
  cPartyDetailsRequestResult.destroy = (void (*)(void *)) free_FIX_PartyDetailsRequestResult;
  cPartyDetailsRequestResult.trackObjects = 0;
  
  cExerciseMethod.klass = rb_define_class_under(mQuickfix, "ExerciseMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExerciseMethod, (void *) &cExerciseMethod);
  rb_define_alloc_func(cExerciseMethod.klass, _wrap_ExerciseMethod_allocate);
  rb_define_method(cExerciseMethod.klass, "initialize", VALUEFUNC(_wrap_new_ExerciseMethod), -1);
  cExerciseMethod.mark = 0;
  cExerciseMethod.destroy = (void (*)(void *)) free_FIX_ExerciseMethod;
  cExerciseMethod.trackObjects = 0;
  
  cCommCurrency.klass = rb_define_class_under(mQuickfix, "CommCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CommCurrency, (void *) &cCommCurrency);
  rb_define_alloc_func(cCommCurrency.klass, _wrap_CommCurrency_allocate);
  rb_define_method(cCommCurrency.klass, "initialize", VALUEFUNC(_wrap_new_CommCurrency), -1);
  cCommCurrency.mark = 0;
  cCommCurrency.destroy = (void (*)(void *)) free_FIX_CommCurrency;
  cCommCurrency.trackObjects = 0;
  
  cNoSettlOblig.klass = rb_define_class_under(mQuickfix, "NoSettlOblig", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlOblig, (void *) &cNoSettlOblig);
  rb_define_alloc_func(cNoSettlOblig.klass, _wrap_NoSettlOblig_allocate);
  rb_define_method(cNoSettlOblig.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlOblig), -1);
  cNoSettlOblig.mark = 0;
  cNoSettlOblig.destroy = (void (*)(void *)) free_FIX_NoSettlOblig;
  cNoSettlOblig.trackObjects = 0;
  
  cMaxPriceVariation.klass = rb_define_class_under(mQuickfix, "MaxPriceVariation", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxPriceVariation, (void *) &cMaxPriceVariation);
  rb_define_alloc_func(cMaxPriceVariation.klass, _wrap_MaxPriceVariation_allocate);
  rb_define_method(cMaxPriceVariation.klass, "initialize", VALUEFUNC(_wrap_new_MaxPriceVariation), -1);
  cMaxPriceVariation.mark = 0;
  cMaxPriceVariation.destroy = (void (*)(void *)) free_FIX_MaxPriceVariation;
  cMaxPriceVariation.trackObjects = 0;
  
  cWorkingIndicator.klass = rb_define_class_under(mQuickfix, "WorkingIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__WorkingIndicator, (void *) &cWorkingIndicator);
  rb_define_alloc_func(cWorkingIndicator.klass, _wrap_WorkingIndicator_allocate);
  rb_define_method(cWorkingIndicator.klass, "initialize", VALUEFUNC(_wrap_new_WorkingIndicator), -1);
  cWorkingIndicator.mark = 0;
  cWorkingIndicator.destroy = (void (*)(void *)) free_FIX_WorkingIndicator;
  cWorkingIndicator.trackObjects = 0;
  
  cCashSettlAgentAcctName.klass = rb_define_class_under(mQuickfix, "CashSettlAgentAcctName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentAcctName, (void *) &cCashSettlAgentAcctName);
  rb_define_alloc_func(cCashSettlAgentAcctName.klass, _wrap_CashSettlAgentAcctName_allocate);
  rb_define_method(cCashSettlAgentAcctName.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentAcctName), -1);
  cCashSettlAgentAcctName.mark = 0;
  cCashSettlAgentAcctName.destroy = (void (*)(void *)) free_FIX_CashSettlAgentAcctName;
  cCashSettlAgentAcctName.trackObjects = 0;
  
  cSellVolume.klass = rb_define_class_under(mQuickfix, "SellVolume", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SellVolume, (void *) &cSellVolume);
  rb_define_alloc_func(cSellVolume.klass, _wrap_SellVolume_allocate);
  rb_define_method(cSellVolume.klass, "initialize", VALUEFUNC(_wrap_new_SellVolume), -1);
  cSellVolume.mark = 0;
  cSellVolume.destroy = (void (*)(void *)) free_FIX_SellVolume;
  cSellVolume.trackObjects = 0;
  
  cSideMultiLegReportingType.klass = rb_define_class_under(mQuickfix, "SideMultiLegReportingType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideMultiLegReportingType, (void *) &cSideMultiLegReportingType);
  rb_define_alloc_func(cSideMultiLegReportingType.klass, _wrap_SideMultiLegReportingType_allocate);
  rb_define_method(cSideMultiLegReportingType.klass, "initialize", VALUEFUNC(_wrap_new_SideMultiLegReportingType), -1);
  cSideMultiLegReportingType.mark = 0;
  cSideMultiLegReportingType.destroy = (void (*)(void *)) free_FIX_SideMultiLegReportingType;
  cSideMultiLegReportingType.trackObjects = 0;
  
  cDerivativeEventText.klass = rb_define_class_under(mQuickfix, "DerivativeEventText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventText, (void *) &cDerivativeEventText);
  rb_define_alloc_func(cDerivativeEventText.klass, _wrap_DerivativeEventText_allocate);
  rb_define_method(cDerivativeEventText.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventText), -1);
  cDerivativeEventText.mark = 0;
  cDerivativeEventText.destroy = (void (*)(void *)) free_FIX_DerivativeEventText;
  cDerivativeEventText.trackObjects = 0;
  
  cPegSecurityDesc.klass = rb_define_class_under(mQuickfix, "PegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSecurityDesc, (void *) &cPegSecurityDesc);
  rb_define_alloc_func(cPegSecurityDesc.klass, _wrap_PegSecurityDesc_allocate);
  rb_define_method(cPegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_PegSecurityDesc), -1);
  cPegSecurityDesc.mark = 0;
  cPegSecurityDesc.destroy = (void (*)(void *)) free_FIX_PegSecurityDesc;
  cPegSecurityDesc.trackObjects = 0;
  
  cAllocCustomerCapacity.klass = rb_define_class_under(mQuickfix, "AllocCustomerCapacity", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocCustomerCapacity, (void *) &cAllocCustomerCapacity);
  rb_define_alloc_func(cAllocCustomerCapacity.klass, _wrap_AllocCustomerCapacity_allocate);
  rb_define_method(cAllocCustomerCapacity.klass, "initialize", VALUEFUNC(_wrap_new_AllocCustomerCapacity), -1);
  cAllocCustomerCapacity.mark = 0;
  cAllocCustomerCapacity.destroy = (void (*)(void *)) free_FIX_AllocCustomerCapacity;
  cAllocCustomerCapacity.trackObjects = 0;
  
  cConfirmRejReason.klass = rb_define_class_under(mQuickfix, "ConfirmRejReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmRejReason, (void *) &cConfirmRejReason);
  rb_define_alloc_func(cConfirmRejReason.klass, _wrap_ConfirmRejReason_allocate);
  rb_define_method(cConfirmRejReason.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmRejReason), -1);
  cConfirmRejReason.mark = 0;
  cConfirmRejReason.destroy = (void (*)(void *)) free_FIX_ConfirmRejReason;
  cConfirmRejReason.trackObjects = 0;
  
  cBidRequestTransType.klass = rb_define_class_under(mQuickfix, "BidRequestTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidRequestTransType, (void *) &cBidRequestTransType);
  rb_define_alloc_func(cBidRequestTransType.klass, _wrap_BidRequestTransType_allocate);
  rb_define_method(cBidRequestTransType.klass, "initialize", VALUEFUNC(_wrap_new_BidRequestTransType), -1);
  cBidRequestTransType.mark = 0;
  cBidRequestTransType.destroy = (void (*)(void *)) free_FIX_BidRequestTransType;
  cBidRequestTransType.trackObjects = 0;
  
  cCashDistribAgentAcctNumber.klass = rb_define_class_under(mQuickfix, "CashDistribAgentAcctNumber", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentAcctNumber, (void *) &cCashDistribAgentAcctNumber);
  rb_define_alloc_func(cCashDistribAgentAcctNumber.klass, _wrap_CashDistribAgentAcctNumber_allocate);
  rb_define_method(cCashDistribAgentAcctNumber.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentAcctNumber), -1);
  cCashDistribAgentAcctNumber.mark = 0;
  cCashDistribAgentAcctNumber.destroy = (void (*)(void *)) free_FIX_CashDistribAgentAcctNumber;
  cCashDistribAgentAcctNumber.trackObjects = 0;
  
  cLegExecInst.klass = rb_define_class_under(mQuickfix, "LegExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegExecInst, (void *) &cLegExecInst);
  rb_define_alloc_func(cLegExecInst.klass, _wrap_LegExecInst_allocate);
  rb_define_method(cLegExecInst.klass, "initialize", VALUEFUNC(_wrap_new_LegExecInst), -1);
  cLegExecInst.mark = 0;
  cLegExecInst.destroy = (void (*)(void *)) free_FIX_LegExecInst;
  cLegExecInst.trackObjects = 0;
  
  cCapPrice.klass = rb_define_class_under(mQuickfix, "CapPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CapPrice, (void *) &cCapPrice);
  rb_define_alloc_func(cCapPrice.klass, _wrap_CapPrice_allocate);
  rb_define_method(cCapPrice.klass, "initialize", VALUEFUNC(_wrap_new_CapPrice), -1);
  cCapPrice.mark = 0;
  cCapPrice.destroy = (void (*)(void *)) free_FIX_CapPrice;
  cCapPrice.trackObjects = 0;
  
  cLegRepurchaseTerm.klass = rb_define_class_under(mQuickfix, "LegRepurchaseTerm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRepurchaseTerm, (void *) &cLegRepurchaseTerm);
  rb_define_alloc_func(cLegRepurchaseTerm.klass, _wrap_LegRepurchaseTerm_allocate);
  rb_define_method(cLegRepurchaseTerm.klass, "initialize", VALUEFUNC(_wrap_new_LegRepurchaseTerm), -1);
  cLegRepurchaseTerm.mark = 0;
  cLegRepurchaseTerm.destroy = (void (*)(void *)) free_FIX_LegRepurchaseTerm;
  cLegRepurchaseTerm.trackObjects = 0;
  
  cRegistAcctType.klass = rb_define_class_under(mQuickfix, "RegistAcctType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistAcctType, (void *) &cRegistAcctType);
  rb_define_alloc_func(cRegistAcctType.klass, _wrap_RegistAcctType_allocate);
  rb_define_method(cRegistAcctType.klass, "initialize", VALUEFUNC(_wrap_new_RegistAcctType), -1);
  cRegistAcctType.mark = 0;
  cRegistAcctType.destroy = (void (*)(void *)) free_FIX_RegistAcctType;
  cRegistAcctType.trackObjects = 0;
  
  cMassActionRejectReason.klass = rb_define_class_under(mQuickfix, "MassActionRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionRejectReason, (void *) &cMassActionRejectReason);
  rb_define_alloc_func(cMassActionRejectReason.klass, _wrap_MassActionRejectReason_allocate);
  rb_define_method(cMassActionRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_MassActionRejectReason), -1);
  cMassActionRejectReason.mark = 0;
  cMassActionRejectReason.destroy = (void (*)(void *)) free_FIX_MassActionRejectReason;
  cMassActionRejectReason.trackObjects = 0;
  
  cDerivativePutOrCall.klass = rb_define_class_under(mQuickfix, "DerivativePutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePutOrCall, (void *) &cDerivativePutOrCall);
  rb_define_alloc_func(cDerivativePutOrCall.klass, _wrap_DerivativePutOrCall_allocate);
  rb_define_method(cDerivativePutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePutOrCall), -1);
  cDerivativePutOrCall.mark = 0;
  cDerivativePutOrCall.destroy = (void (*)(void *)) free_FIX_DerivativePutOrCall;
  cDerivativePutOrCall.trackObjects = 0;
  
  cStartMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "StartMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartMaturityMonthYear, (void *) &cStartMaturityMonthYear);
  rb_define_alloc_func(cStartMaturityMonthYear.klass, _wrap_StartMaturityMonthYear_allocate);
  rb_define_method(cStartMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_StartMaturityMonthYear), -1);
  cStartMaturityMonthYear.mark = 0;
  cStartMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_StartMaturityMonthYear;
  cStartMaturityMonthYear.trackObjects = 0;
  
  cCollApplType.klass = rb_define_class_under(mQuickfix, "CollApplType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollApplType, (void *) &cCollApplType);
  rb_define_alloc_func(cCollApplType.klass, _wrap_CollApplType_allocate);
  rb_define_method(cCollApplType.klass, "initialize", VALUEFUNC(_wrap_new_CollApplType), -1);
  cCollApplType.mark = 0;
  cCollApplType.destroy = (void (*)(void *)) free_FIX_CollApplType;
  cCollApplType.trackObjects = 0;
  
  cNoUnderlyingAmounts.klass = rb_define_class_under(mQuickfix, "NoUnderlyingAmounts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingAmounts, (void *) &cNoUnderlyingAmounts);
  rb_define_alloc_func(cNoUnderlyingAmounts.klass, _wrap_NoUnderlyingAmounts_allocate);
  rb_define_method(cNoUnderlyingAmounts.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingAmounts), -1);
  cNoUnderlyingAmounts.mark = 0;
  cNoUnderlyingAmounts.destroy = (void (*)(void *)) free_FIX_NoUnderlyingAmounts;
  cNoUnderlyingAmounts.trackObjects = 0;
  
  cConfirmType.klass = rb_define_class_under(mQuickfix, "ConfirmType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmType, (void *) &cConfirmType);
  rb_define_alloc_func(cConfirmType.klass, _wrap_ConfirmType_allocate);
  rb_define_method(cConfirmType.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmType), -1);
  cConfirmType.mark = 0;
  cConfirmType.destroy = (void (*)(void *)) free_FIX_ConfirmType;
  cConfirmType.trackObjects = 0;
  
  cLegMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "LegMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegMaturityMonthYear, (void *) &cLegMaturityMonthYear);
  rb_define_alloc_func(cLegMaturityMonthYear.klass, _wrap_LegMaturityMonthYear_allocate);
  rb_define_method(cLegMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_LegMaturityMonthYear), -1);
  cLegMaturityMonthYear.mark = 0;
  cLegMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_LegMaturityMonthYear;
  cLegMaturityMonthYear.trackObjects = 0;
  
  cRelatdSym.klass = rb_define_class_under(mQuickfix, "RelatdSym", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatdSym, (void *) &cRelatdSym);
  rb_define_alloc_func(cRelatdSym.klass, _wrap_RelatdSym_allocate);
  rb_define_method(cRelatdSym.klass, "initialize", VALUEFUNC(_wrap_new_RelatdSym), -1);
  cRelatdSym.mark = 0;
  cRelatdSym.destroy = (void (*)(void *)) free_FIX_RelatdSym;
  cRelatdSym.trackObjects = 0;
  
  cRiskLimitAmount.klass = rb_define_class_under(mQuickfix, "RiskLimitAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskLimitAmount, (void *) &cRiskLimitAmount);
  rb_define_alloc_func(cRiskLimitAmount.klass, _wrap_RiskLimitAmount_allocate);
  rb_define_method(cRiskLimitAmount.klass, "initialize", VALUEFUNC(_wrap_new_RiskLimitAmount), -1);
  cRiskLimitAmount.mark = 0;
  cRiskLimitAmount.destroy = (void (*)(void *)) free_FIX_RiskLimitAmount;
  cRiskLimitAmount.trackObjects = 0;
  
  cUnderlyingLegSecuritySubType.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecuritySubType, (void *) &cUnderlyingLegSecuritySubType);
  rb_define_alloc_func(cUnderlyingLegSecuritySubType.klass, _wrap_UnderlyingLegSecuritySubType_allocate);
  rb_define_method(cUnderlyingLegSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecuritySubType), -1);
  cUnderlyingLegSecuritySubType.mark = 0;
  cUnderlyingLegSecuritySubType.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecuritySubType;
  cUnderlyingLegSecuritySubType.trackObjects = 0;
  
  cNoUnderlyingSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoUnderlyingSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingSecurityAltID, (void *) &cNoUnderlyingSecurityAltID);
  rb_define_alloc_func(cNoUnderlyingSecurityAltID.klass, _wrap_NoUnderlyingSecurityAltID_allocate);
  rb_define_method(cNoUnderlyingSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingSecurityAltID), -1);
  cNoUnderlyingSecurityAltID.mark = 0;
  cNoUnderlyingSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoUnderlyingSecurityAltID;
  cNoUnderlyingSecurityAltID.trackObjects = 0;
  
  cRelationshipRiskCFICode.klass = rb_define_class_under(mQuickfix, "RelationshipRiskCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskCFICode, (void *) &cRelationshipRiskCFICode);
  rb_define_alloc_func(cRelationshipRiskCFICode.klass, _wrap_RelationshipRiskCFICode_allocate);
  rb_define_method(cRelationshipRiskCFICode.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskCFICode), -1);
  cRelationshipRiskCFICode.mark = 0;
  cRelationshipRiskCFICode.destroy = (void (*)(void *)) free_FIX_RelationshipRiskCFICode;
  cRelationshipRiskCFICode.trackObjects = 0;
  
  cNoRelatedPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoRelatedPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedPartySubIDs, (void *) &cNoRelatedPartySubIDs);
  rb_define_alloc_func(cNoRelatedPartySubIDs.klass, _wrap_NoRelatedPartySubIDs_allocate);
  rb_define_method(cNoRelatedPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedPartySubIDs), -1);
  cNoRelatedPartySubIDs.mark = 0;
  cNoRelatedPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoRelatedPartySubIDs;
  cNoRelatedPartySubIDs.trackObjects = 0;
  
  cRiskSymbolSfx.klass = rb_define_class_under(mQuickfix, "RiskSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSymbolSfx, (void *) &cRiskSymbolSfx);
  rb_define_alloc_func(cRiskSymbolSfx.klass, _wrap_RiskSymbolSfx_allocate);
  rb_define_method(cRiskSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_RiskSymbolSfx), -1);
  cRiskSymbolSfx.mark = 0;
  cRiskSymbolSfx.destroy = (void (*)(void *)) free_FIX_RiskSymbolSfx;
  cRiskSymbolSfx.trackObjects = 0;
  
  cMDQuoteType.klass = rb_define_class_under(mQuickfix, "MDQuoteType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDQuoteType, (void *) &cMDQuoteType);
  rb_define_alloc_func(cMDQuoteType.klass, _wrap_MDQuoteType_allocate);
  rb_define_method(cMDQuoteType.klass, "initialize", VALUEFUNC(_wrap_new_MDQuoteType), -1);
  cMDQuoteType.mark = 0;
  cMDQuoteType.destroy = (void (*)(void *)) free_FIX_MDQuoteType;
  cMDQuoteType.trackObjects = 0;
  
  cQtyType.klass = rb_define_class_under(mQuickfix, "QtyType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QtyType, (void *) &cQtyType);
  rb_define_alloc_func(cQtyType.klass, _wrap_QtyType_allocate);
  rb_define_method(cQtyType.klass, "initialize", VALUEFUNC(_wrap_new_QtyType), -1);
  cQtyType.mark = 0;
  cQtyType.destroy = (void (*)(void *)) free_FIX_QtyType;
  cQtyType.trackObjects = 0;
  
  cQuoteRespType.klass = rb_define_class_under(mQuickfix, "QuoteRespType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRespType, (void *) &cQuoteRespType);
  rb_define_alloc_func(cQuoteRespType.klass, _wrap_QuoteRespType_allocate);
  rb_define_method(cQuoteRespType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRespType), -1);
  cQuoteRespType.mark = 0;
  cQuoteRespType.destroy = (void (*)(void *)) free_FIX_QuoteRespType;
  cQuoteRespType.trackObjects = 0;
  
  cIOINaturalFlag.klass = rb_define_class_under(mQuickfix, "IOINaturalFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOINaturalFlag, (void *) &cIOINaturalFlag);
  rb_define_alloc_func(cIOINaturalFlag.klass, _wrap_IOINaturalFlag_allocate);
  rb_define_method(cIOINaturalFlag.klass, "initialize", VALUEFUNC(_wrap_new_IOINaturalFlag), -1);
  cIOINaturalFlag.mark = 0;
  cIOINaturalFlag.destroy = (void (*)(void *)) free_FIX_IOINaturalFlag;
  cIOINaturalFlag.trackObjects = 0;
  
  cBenchmarkCurvePoint.klass = rb_define_class_under(mQuickfix, "BenchmarkCurvePoint", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkCurvePoint, (void *) &cBenchmarkCurvePoint);
  rb_define_alloc_func(cBenchmarkCurvePoint.klass, _wrap_BenchmarkCurvePoint_allocate);
  rb_define_method(cBenchmarkCurvePoint.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkCurvePoint), -1);
  cBenchmarkCurvePoint.mark = 0;
  cBenchmarkCurvePoint.destroy = (void (*)(void *)) free_FIX_BenchmarkCurvePoint;
  cBenchmarkCurvePoint.trackObjects = 0;
  
  cTradSesUpdateAction.klass = rb_define_class_under(mQuickfix, "TradSesUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesUpdateAction, (void *) &cTradSesUpdateAction);
  rb_define_alloc_func(cTradSesUpdateAction.klass, _wrap_TradSesUpdateAction_allocate);
  rb_define_method(cTradSesUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_TradSesUpdateAction), -1);
  cTradSesUpdateAction.mark = 0;
  cTradSesUpdateAction.destroy = (void (*)(void *)) free_FIX_TradSesUpdateAction;
  cTradSesUpdateAction.trackObjects = 0;
  
  cUnderlyingCashAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingCashAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCashAmount, (void *) &cUnderlyingCashAmount);
  rb_define_alloc_func(cUnderlyingCashAmount.klass, _wrap_UnderlyingCashAmount_allocate);
  rb_define_method(cUnderlyingCashAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCashAmount), -1);
  cUnderlyingCashAmount.mark = 0;
  cUnderlyingCashAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingCashAmount;
  cUnderlyingCashAmount.trackObjects = 0;
  
  cCollAsgnID.klass = rb_define_class_under(mQuickfix, "CollAsgnID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnID, (void *) &cCollAsgnID);
  rb_define_alloc_func(cCollAsgnID.klass, _wrap_CollAsgnID_allocate);
  rb_define_method(cCollAsgnID.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnID), -1);
  cCollAsgnID.mark = 0;
  cCollAsgnID.destroy = (void (*)(void *)) free_FIX_CollAsgnID;
  cCollAsgnID.trackObjects = 0;
  
  cExchangeRule.klass = rb_define_class_under(mQuickfix, "ExchangeRule", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExchangeRule, (void *) &cExchangeRule);
  rb_define_alloc_func(cExchangeRule.klass, _wrap_ExchangeRule_allocate);
  rb_define_method(cExchangeRule.klass, "initialize", VALUEFUNC(_wrap_new_ExchangeRule), -1);
  cExchangeRule.mark = 0;
  cExchangeRule.destroy = (void (*)(void *)) free_FIX_ExchangeRule;
  cExchangeRule.trackObjects = 0;
  
  cEncodedHeadline.klass = rb_define_class_under(mQuickfix, "EncodedHeadline", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedHeadline, (void *) &cEncodedHeadline);
  rb_define_alloc_func(cEncodedHeadline.klass, _wrap_EncodedHeadline_allocate);
  rb_define_method(cEncodedHeadline.klass, "initialize", VALUEFUNC(_wrap_new_EncodedHeadline), -1);
  cEncodedHeadline.mark = 0;
  cEncodedHeadline.destroy = (void (*)(void *)) free_FIX_EncodedHeadline;
  cEncodedHeadline.trackObjects = 0;
  
  cRegistID.klass = rb_define_class_under(mQuickfix, "RegistID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistID, (void *) &cRegistID);
  rb_define_alloc_func(cRegistID.klass, _wrap_RegistID_allocate);
  rb_define_method(cRegistID.klass, "initialize", VALUEFUNC(_wrap_new_RegistID), -1);
  cRegistID.mark = 0;
  cRegistID.destroy = (void (*)(void *)) free_FIX_RegistID;
  cRegistID.trackObjects = 0;
  
  cCrossID.klass = rb_define_class_under(mQuickfix, "CrossID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossID, (void *) &cCrossID);
  rb_define_alloc_func(cCrossID.klass, _wrap_CrossID_allocate);
  rb_define_method(cCrossID.klass, "initialize", VALUEFUNC(_wrap_new_CrossID), -1);
  cCrossID.mark = 0;
  cCrossID.destroy = (void (*)(void *)) free_FIX_CrossID;
  cCrossID.trackObjects = 0;
  
  cNoExecs.klass = rb_define_class_under(mQuickfix, "NoExecs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoExecs, (void *) &cNoExecs);
  rb_define_alloc_func(cNoExecs.klass, _wrap_NoExecs_allocate);
  rb_define_method(cNoExecs.klass, "initialize", VALUEFUNC(_wrap_new_NoExecs), -1);
  cNoExecs.mark = 0;
  cNoExecs.destroy = (void (*)(void *)) free_FIX_NoExecs;
  cNoExecs.trackObjects = 0;
  
  cDerivativeSecurityGroup.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityGroup", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityGroup, (void *) &cDerivativeSecurityGroup);
  rb_define_alloc_func(cDerivativeSecurityGroup.klass, _wrap_DerivativeSecurityGroup_allocate);
  rb_define_method(cDerivativeSecurityGroup.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityGroup), -1);
  cDerivativeSecurityGroup.mark = 0;
  cDerivativeSecurityGroup.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityGroup;
  cDerivativeSecurityGroup.trackObjects = 0;
  
  cSecondaryDisplayQty.klass = rb_define_class_under(mQuickfix, "SecondaryDisplayQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryDisplayQty, (void *) &cSecondaryDisplayQty);
  rb_define_alloc_func(cSecondaryDisplayQty.klass, _wrap_SecondaryDisplayQty_allocate);
  rb_define_method(cSecondaryDisplayQty.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryDisplayQty), -1);
  cSecondaryDisplayQty.mark = 0;
  cSecondaryDisplayQty.destroy = (void (*)(void *)) free_FIX_SecondaryDisplayQty;
  cSecondaryDisplayQty.trackObjects = 0;
  
  cRefMsgType.klass = rb_define_class_under(mQuickfix, "RefMsgType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefMsgType, (void *) &cRefMsgType);
  rb_define_alloc_func(cRefMsgType.klass, _wrap_RefMsgType_allocate);
  rb_define_method(cRefMsgType.klass, "initialize", VALUEFUNC(_wrap_new_RefMsgType), -1);
  cRefMsgType.mark = 0;
  cRefMsgType.destroy = (void (*)(void *)) free_FIX_RefMsgType;
  cRefMsgType.trackObjects = 0;
  
  cStandInstDbID.klass = rb_define_class_under(mQuickfix, "StandInstDbID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StandInstDbID, (void *) &cStandInstDbID);
  rb_define_alloc_func(cStandInstDbID.klass, _wrap_StandInstDbID_allocate);
  rb_define_method(cStandInstDbID.klass, "initialize", VALUEFUNC(_wrap_new_StandInstDbID), -1);
  cStandInstDbID.mark = 0;
  cStandInstDbID.destroy = (void (*)(void *)) free_FIX_StandInstDbID;
  cStandInstDbID.trackObjects = 0;
  
  cEncodedLegSecurityDescLen.klass = rb_define_class_under(mQuickfix, "EncodedLegSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegSecurityDescLen, (void *) &cEncodedLegSecurityDescLen);
  rb_define_alloc_func(cEncodedLegSecurityDescLen.klass, _wrap_EncodedLegSecurityDescLen_allocate);
  rb_define_method(cEncodedLegSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegSecurityDescLen), -1);
  cEncodedLegSecurityDescLen.mark = 0;
  cEncodedLegSecurityDescLen.destroy = (void (*)(void *)) free_FIX_EncodedLegSecurityDescLen;
  cEncodedLegSecurityDescLen.trackObjects = 0;
  
  cDerivativeEventPx.klass = rb_define_class_under(mQuickfix, "DerivativeEventPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEventPx, (void *) &cDerivativeEventPx);
  rb_define_alloc_func(cDerivativeEventPx.klass, _wrap_DerivativeEventPx_allocate);
  rb_define_method(cDerivativeEventPx.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEventPx), -1);
  cDerivativeEventPx.mark = 0;
  cDerivativeEventPx.destroy = (void (*)(void *)) free_FIX_DerivativeEventPx;
  cDerivativeEventPx.trackObjects = 0;
  
  cSettlObligSource.klass = rb_define_class_under(mQuickfix, "SettlObligSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligSource, (void *) &cSettlObligSource);
  rb_define_alloc_func(cSettlObligSource.klass, _wrap_SettlObligSource_allocate);
  rb_define_method(cSettlObligSource.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligSource), -1);
  cSettlObligSource.mark = 0;
  cSettlObligSource.destroy = (void (*)(void *)) free_FIX_SettlObligSource;
  cSettlObligSource.trackObjects = 0;
  
  cTrdSubType.klass = rb_define_class_under(mQuickfix, "TrdSubType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdSubType, (void *) &cTrdSubType);
  rb_define_alloc_func(cTrdSubType.klass, _wrap_TrdSubType_allocate);
  rb_define_method(cTrdSubType.klass, "initialize", VALUEFUNC(_wrap_new_TrdSubType), -1);
  cTrdSubType.mark = 0;
  cTrdSubType.destroy = (void (*)(void *)) free_FIX_TrdSubType;
  cTrdSubType.trackObjects = 0;
  
  cEncodedUnderlyingIssuerLen.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingIssuerLen, (void *) &cEncodedUnderlyingIssuerLen);
  rb_define_alloc_func(cEncodedUnderlyingIssuerLen.klass, _wrap_EncodedUnderlyingIssuerLen_allocate);
  rb_define_method(cEncodedUnderlyingIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingIssuerLen), -1);
  cEncodedUnderlyingIssuerLen.mark = 0;
  cEncodedUnderlyingIssuerLen.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingIssuerLen;
  cEncodedUnderlyingIssuerLen.trackObjects = 0;
  
  cExecTransType.klass = rb_define_class_under(mQuickfix, "ExecTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecTransType, (void *) &cExecTransType);
  rb_define_alloc_func(cExecTransType.klass, _wrap_ExecTransType_allocate);
  rb_define_method(cExecTransType.klass, "initialize", VALUEFUNC(_wrap_new_ExecTransType), -1);
  cExecTransType.mark = 0;
  cExecTransType.destroy = (void (*)(void *)) free_FIX_ExecTransType;
  cExecTransType.trackObjects = 0;
  
  cBeginSeqNo.klass = rb_define_class_under(mQuickfix, "BeginSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BeginSeqNo, (void *) &cBeginSeqNo);
  rb_define_alloc_func(cBeginSeqNo.klass, _wrap_BeginSeqNo_allocate);
  rb_define_method(cBeginSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_BeginSeqNo), -1);
  cBeginSeqNo.mark = 0;
  cBeginSeqNo.destroy = (void (*)(void *)) free_FIX_BeginSeqNo;
  cBeginSeqNo.trackObjects = 0;
  
  cDayBookingInst.klass = rb_define_class_under(mQuickfix, "DayBookingInst", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DayBookingInst, (void *) &cDayBookingInst);
  rb_define_alloc_func(cDayBookingInst.klass, _wrap_DayBookingInst_allocate);
  rb_define_method(cDayBookingInst.klass, "initialize", VALUEFUNC(_wrap_new_DayBookingInst), -1);
  cDayBookingInst.mark = 0;
  cDayBookingInst.destroy = (void (*)(void *)) free_FIX_DayBookingInst;
  cDayBookingInst.trackObjects = 0;
  
  cFlowScheduleType.klass = rb_define_class_under(mQuickfix, "FlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FlowScheduleType, (void *) &cFlowScheduleType);
  rb_define_alloc_func(cFlowScheduleType.klass, _wrap_FlowScheduleType_allocate);
  rb_define_method(cFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_FlowScheduleType), -1);
  cFlowScheduleType.mark = 0;
  cFlowScheduleType.destroy = (void (*)(void *)) free_FIX_FlowScheduleType;
  cFlowScheduleType.trackObjects = 0;
  
  cMDOriginType.klass = rb_define_class_under(mQuickfix, "MDOriginType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDOriginType, (void *) &cMDOriginType);
  rb_define_alloc_func(cMDOriginType.klass, _wrap_MDOriginType_allocate);
  rb_define_method(cMDOriginType.klass, "initialize", VALUEFUNC(_wrap_new_MDOriginType), -1);
  cMDOriginType.mark = 0;
  cMDOriginType.destroy = (void (*)(void *)) free_FIX_MDOriginType;
  cMDOriginType.trackObjects = 0;
  
  cCollInquiryStatus.klass = rb_define_class_under(mQuickfix, "CollInquiryStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryStatus, (void *) &cCollInquiryStatus);
  rb_define_alloc_func(cCollInquiryStatus.klass, _wrap_CollInquiryStatus_allocate);
  rb_define_method(cCollInquiryStatus.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryStatus), -1);
  cCollInquiryStatus.mark = 0;
  cCollInquiryStatus.destroy = (void (*)(void *)) free_FIX_CollInquiryStatus;
  cCollInquiryStatus.trackObjects = 0;
  
  cNoInstrAttrib.klass = rb_define_class_under(mQuickfix, "NoInstrAttrib", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoInstrAttrib, (void *) &cNoInstrAttrib);
  rb_define_alloc_func(cNoInstrAttrib.klass, _wrap_NoInstrAttrib_allocate);
  rb_define_method(cNoInstrAttrib.klass, "initialize", VALUEFUNC(_wrap_new_NoInstrAttrib), -1);
  cNoInstrAttrib.mark = 0;
  cNoInstrAttrib.destroy = (void (*)(void *)) free_FIX_NoInstrAttrib;
  cNoInstrAttrib.trackObjects = 0;
  
  cRegistEmail.klass = rb_define_class_under(mQuickfix, "RegistEmail", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistEmail, (void *) &cRegistEmail);
  rb_define_alloc_func(cRegistEmail.klass, _wrap_RegistEmail_allocate);
  rb_define_method(cRegistEmail.klass, "initialize", VALUEFUNC(_wrap_new_RegistEmail), -1);
  cRegistEmail.mark = 0;
  cRegistEmail.destroy = (void (*)(void *)) free_FIX_RegistEmail;
  cRegistEmail.trackObjects = 0;
  
  cStreamAsgnReqID.klass = rb_define_class_under(mQuickfix, "StreamAsgnReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnReqID, (void *) &cStreamAsgnReqID);
  rb_define_alloc_func(cStreamAsgnReqID.klass, _wrap_StreamAsgnReqID_allocate);
  rb_define_method(cStreamAsgnReqID.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnReqID), -1);
  cStreamAsgnReqID.mark = 0;
  cStreamAsgnReqID.destroy = (void (*)(void *)) free_FIX_StreamAsgnReqID;
  cStreamAsgnReqID.trackObjects = 0;
  
  cCPProgram.klass = rb_define_class_under(mQuickfix, "CPProgram", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CPProgram, (void *) &cCPProgram);
  rb_define_alloc_func(cCPProgram.klass, _wrap_CPProgram_allocate);
  rb_define_method(cCPProgram.klass, "initialize", VALUEFUNC(_wrap_new_CPProgram), -1);
  cCPProgram.mark = 0;
  cCPProgram.destroy = (void (*)(void *)) free_FIX_CPProgram;
  cCPProgram.trackObjects = 0;
  
  cConfirmReqID.klass = rb_define_class_under(mQuickfix, "ConfirmReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmReqID, (void *) &cConfirmReqID);
  rb_define_alloc_func(cConfirmReqID.klass, _wrap_ConfirmReqID_allocate);
  rb_define_method(cConfirmReqID.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmReqID), -1);
  cConfirmReqID.mark = 0;
  cConfirmReqID.destroy = (void (*)(void *)) free_FIX_ConfirmReqID;
  cConfirmReqID.trackObjects = 0;
  
  cAltMDSourceID.klass = rb_define_class_under(mQuickfix, "AltMDSourceID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AltMDSourceID, (void *) &cAltMDSourceID);
  rb_define_alloc_func(cAltMDSourceID.klass, _wrap_AltMDSourceID_allocate);
  rb_define_method(cAltMDSourceID.klass, "initialize", VALUEFUNC(_wrap_new_AltMDSourceID), -1);
  cAltMDSourceID.mark = 0;
  cAltMDSourceID.destroy = (void (*)(void *)) free_FIX_AltMDSourceID;
  cAltMDSourceID.trackObjects = 0;
  
  cNoOrders.klass = rb_define_class_under(mQuickfix, "NoOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOrders, (void *) &cNoOrders);
  rb_define_alloc_func(cNoOrders.klass, _wrap_NoOrders_allocate);
  rb_define_method(cNoOrders.klass, "initialize", VALUEFUNC(_wrap_new_NoOrders), -1);
  cNoOrders.mark = 0;
  cNoOrders.destroy = (void (*)(void *)) free_FIX_NoOrders;
  cNoOrders.trackObjects = 0;
  
  cCashDistribAgentAcctName.klass = rb_define_class_under(mQuickfix, "CashDistribAgentAcctName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribAgentAcctName, (void *) &cCashDistribAgentAcctName);
  rb_define_alloc_func(cCashDistribAgentAcctName.klass, _wrap_CashDistribAgentAcctName_allocate);
  rb_define_method(cCashDistribAgentAcctName.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribAgentAcctName), -1);
  cCashDistribAgentAcctName.mark = 0;
  cCashDistribAgentAcctName.destroy = (void (*)(void *)) free_FIX_CashDistribAgentAcctName;
  cCashDistribAgentAcctName.trackObjects = 0;
  
  cNoContextPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoContextPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoContextPartySubIDs, (void *) &cNoContextPartySubIDs);
  rb_define_alloc_func(cNoContextPartySubIDs.klass, _wrap_NoContextPartySubIDs_allocate);
  rb_define_method(cNoContextPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoContextPartySubIDs), -1);
  cNoContextPartySubIDs.mark = 0;
  cNoContextPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoContextPartySubIDs;
  cNoContextPartySubIDs.trackObjects = 0;
  
  cUndlyInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartyIDSource, (void *) &cUndlyInstrumentPartyIDSource);
  rb_define_alloc_func(cUndlyInstrumentPartyIDSource.klass, _wrap_UndlyInstrumentPartyIDSource_allocate);
  rb_define_method(cUndlyInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartyIDSource), -1);
  cUndlyInstrumentPartyIDSource.mark = 0;
  cUndlyInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartyIDSource;
  cUndlyInstrumentPartyIDSource.trackObjects = 0;
  
  cUnderlyingSettlMethod.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlMethod, (void *) &cUnderlyingSettlMethod);
  rb_define_alloc_func(cUnderlyingSettlMethod.klass, _wrap_UnderlyingSettlMethod_allocate);
  rb_define_method(cUnderlyingSettlMethod.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlMethod), -1);
  cUnderlyingSettlMethod.mark = 0;
  cUnderlyingSettlMethod.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlMethod;
  cUnderlyingSettlMethod.trackObjects = 0;
  
  cNoMDEntryTypes.klass = rb_define_class_under(mQuickfix, "NoMDEntryTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMDEntryTypes, (void *) &cNoMDEntryTypes);
  rb_define_alloc_func(cNoMDEntryTypes.klass, _wrap_NoMDEntryTypes_allocate);
  rb_define_method(cNoMDEntryTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoMDEntryTypes), -1);
  cNoMDEntryTypes.mark = 0;
  cNoMDEntryTypes.destroy = (void (*)(void *)) free_FIX_NoMDEntryTypes;
  cNoMDEntryTypes.trackObjects = 0;
  
  cMDEntryForwardPoints.klass = rb_define_class_under(mQuickfix, "MDEntryForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryForwardPoints, (void *) &cMDEntryForwardPoints);
  rb_define_alloc_func(cMDEntryForwardPoints.klass, _wrap_MDEntryForwardPoints_allocate);
  rb_define_method(cMDEntryForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryForwardPoints), -1);
  cMDEntryForwardPoints.mark = 0;
  cMDEntryForwardPoints.destroy = (void (*)(void *)) free_FIX_MDEntryForwardPoints;
  cMDEntryForwardPoints.trackObjects = 0;
  
  cPosReqType.klass = rb_define_class_under(mQuickfix, "PosReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqType, (void *) &cPosReqType);
  rb_define_alloc_func(cPosReqType.klass, _wrap_PosReqType_allocate);
  rb_define_method(cPosReqType.klass, "initialize", VALUEFUNC(_wrap_new_PosReqType), -1);
  cPosReqType.mark = 0;
  cPosReqType.destroy = (void (*)(void *)) free_FIX_PosReqType;
  cPosReqType.trackObjects = 0;
  
  cMassStatusReqType.klass = rb_define_class_under(mQuickfix, "MassStatusReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassStatusReqType, (void *) &cMassStatusReqType);
  rb_define_alloc_func(cMassStatusReqType.klass, _wrap_MassStatusReqType_allocate);
  rb_define_method(cMassStatusReqType.klass, "initialize", VALUEFUNC(_wrap_new_MassStatusReqType), -1);
  cMassStatusReqType.mark = 0;
  cMassStatusReqType.destroy = (void (*)(void *)) free_FIX_MassStatusReqType;
  cMassStatusReqType.trackObjects = 0;
  
  cTradeOriginationDate.klass = rb_define_class_under(mQuickfix, "TradeOriginationDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeOriginationDate, (void *) &cTradeOriginationDate);
  rb_define_alloc_func(cTradeOriginationDate.klass, _wrap_TradeOriginationDate_allocate);
  rb_define_method(cTradeOriginationDate.klass, "initialize", VALUEFUNC(_wrap_new_TradeOriginationDate), -1);
  cTradeOriginationDate.mark = 0;
  cTradeOriginationDate.destroy = (void (*)(void *)) free_FIX_TradeOriginationDate;
  cTradeOriginationDate.trackObjects = 0;
  
  cSettlPrice.klass = rb_define_class_under(mQuickfix, "SettlPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPrice, (void *) &cSettlPrice);
  rb_define_alloc_func(cSettlPrice.klass, _wrap_SettlPrice_allocate);
  rb_define_method(cSettlPrice.klass, "initialize", VALUEFUNC(_wrap_new_SettlPrice), -1);
  cSettlPrice.mark = 0;
  cSettlPrice.destroy = (void (*)(void *)) free_FIX_SettlPrice;
  cSettlPrice.trackObjects = 0;
  
  cSecuritySettlAgentAcctName.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentAcctName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentAcctName, (void *) &cSecuritySettlAgentAcctName);
  rb_define_alloc_func(cSecuritySettlAgentAcctName.klass, _wrap_SecuritySettlAgentAcctName_allocate);
  rb_define_method(cSecuritySettlAgentAcctName.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentAcctName), -1);
  cSecuritySettlAgentAcctName.mark = 0;
  cSecuritySettlAgentAcctName.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentAcctName;
  cSecuritySettlAgentAcctName.trackObjects = 0;
  
  cRiskInstrumentMultiplier.klass = rb_define_class_under(mQuickfix, "RiskInstrumentMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskInstrumentMultiplier, (void *) &cRiskInstrumentMultiplier);
  rb_define_alloc_func(cRiskInstrumentMultiplier.klass, _wrap_RiskInstrumentMultiplier_allocate);
  rb_define_method(cRiskInstrumentMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_RiskInstrumentMultiplier), -1);
  cRiskInstrumentMultiplier.mark = 0;
  cRiskInstrumentMultiplier.destroy = (void (*)(void *)) free_FIX_RiskInstrumentMultiplier;
  cRiskInstrumentMultiplier.trackObjects = 0;
  
  cNoDerivativeEvents.klass = rb_define_class_under(mQuickfix, "NoDerivativeEvents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeEvents, (void *) &cNoDerivativeEvents);
  rb_define_alloc_func(cNoDerivativeEvents.klass, _wrap_NoDerivativeEvents_allocate);
  rb_define_method(cNoDerivativeEvents.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeEvents), -1);
  cNoDerivativeEvents.mark = 0;
  cNoDerivativeEvents.destroy = (void (*)(void *)) free_FIX_NoDerivativeEvents;
  cNoDerivativeEvents.trackObjects = 0;
  
  cUnderlyingEndPrice.klass = rb_define_class_under(mQuickfix, "UnderlyingEndPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingEndPrice, (void *) &cUnderlyingEndPrice);
  rb_define_alloc_func(cUnderlyingEndPrice.klass, _wrap_UnderlyingEndPrice_allocate);
  rb_define_method(cUnderlyingEndPrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingEndPrice), -1);
  cUnderlyingEndPrice.mark = 0;
  cUnderlyingEndPrice.destroy = (void (*)(void *)) free_FIX_UnderlyingEndPrice;
  cUnderlyingEndPrice.trackObjects = 0;
  
  cSubscriptionRequestType.klass = rb_define_class_under(mQuickfix, "SubscriptionRequestType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SubscriptionRequestType, (void *) &cSubscriptionRequestType);
  rb_define_alloc_func(cSubscriptionRequestType.klass, _wrap_SubscriptionRequestType_allocate);
  rb_define_method(cSubscriptionRequestType.klass, "initialize", VALUEFUNC(_wrap_new_SubscriptionRequestType), -1);
  cSubscriptionRequestType.mark = 0;
  cSubscriptionRequestType.destroy = (void (*)(void *)) free_FIX_SubscriptionRequestType;
  cSubscriptionRequestType.trackObjects = 0;
  
  cTotalNumSecurityTypes.klass = rb_define_class_under(mQuickfix, "TotalNumSecurityTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNumSecurityTypes, (void *) &cTotalNumSecurityTypes);
  rb_define_alloc_func(cTotalNumSecurityTypes.klass, _wrap_TotalNumSecurityTypes_allocate);
  rb_define_method(cTotalNumSecurityTypes.klass, "initialize", VALUEFUNC(_wrap_new_TotalNumSecurityTypes), -1);
  cTotalNumSecurityTypes.mark = 0;
  cTotalNumSecurityTypes.destroy = (void (*)(void *)) free_FIX_TotalNumSecurityTypes;
  cTotalNumSecurityTypes.trackObjects = 0;
  
  cNewsCategory.klass = rb_define_class_under(mQuickfix, "NewsCategory", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsCategory, (void *) &cNewsCategory);
  rb_define_alloc_func(cNewsCategory.klass, _wrap_NewsCategory_allocate);
  rb_define_method(cNewsCategory.klass, "initialize", VALUEFUNC(_wrap_new_NewsCategory), -1);
  cNewsCategory.mark = 0;
  cNewsCategory.destroy = (void (*)(void *)) free_FIX_NewsCategory;
  cNewsCategory.trackObjects = 0;
  
  cUnderlyingLegPutOrCall.klass = rb_define_class_under(mQuickfix, "UnderlyingLegPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegPutOrCall, (void *) &cUnderlyingLegPutOrCall);
  rb_define_alloc_func(cUnderlyingLegPutOrCall.klass, _wrap_UnderlyingLegPutOrCall_allocate);
  rb_define_method(cUnderlyingLegPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegPutOrCall), -1);
  cUnderlyingLegPutOrCall.mark = 0;
  cUnderlyingLegPutOrCall.destroy = (void (*)(void *)) free_FIX_UnderlyingLegPutOrCall;
  cUnderlyingLegPutOrCall.trackObjects = 0;
  
  cURLLink.klass = rb_define_class_under(mQuickfix, "URLLink", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__URLLink, (void *) &cURLLink);
  rb_define_alloc_func(cURLLink.klass, _wrap_URLLink_allocate);
  rb_define_method(cURLLink.klass, "initialize", VALUEFUNC(_wrap_new_URLLink), -1);
  cURLLink.mark = 0;
  cURLLink.destroy = (void (*)(void *)) free_FIX_URLLink;
  cURLLink.trackObjects = 0;
  
  cNoInstrumentPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoInstrumentPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoInstrumentPartySubIDs, (void *) &cNoInstrumentPartySubIDs);
  rb_define_alloc_func(cNoInstrumentPartySubIDs.klass, _wrap_NoInstrumentPartySubIDs_allocate);
  rb_define_method(cNoInstrumentPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoInstrumentPartySubIDs), -1);
  cNoInstrumentPartySubIDs.mark = 0;
  cNoInstrumentPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoInstrumentPartySubIDs;
  cNoInstrumentPartySubIDs.trackObjects = 0;
  
  cUnderlyingCurrentValue.klass = rb_define_class_under(mQuickfix, "UnderlyingCurrentValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCurrentValue, (void *) &cUnderlyingCurrentValue);
  rb_define_alloc_func(cUnderlyingCurrentValue.klass, _wrap_UnderlyingCurrentValue_allocate);
  rb_define_method(cUnderlyingCurrentValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCurrentValue), -1);
  cUnderlyingCurrentValue.mark = 0;
  cUnderlyingCurrentValue.destroy = (void (*)(void *)) free_FIX_UnderlyingCurrentValue;
  cUnderlyingCurrentValue.trackObjects = 0;
  
  cInterestAccrualDate.klass = rb_define_class_under(mQuickfix, "InterestAccrualDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InterestAccrualDate, (void *) &cInterestAccrualDate);
  rb_define_alloc_func(cInterestAccrualDate.klass, _wrap_InterestAccrualDate_allocate);
  rb_define_method(cInterestAccrualDate.klass, "initialize", VALUEFUNC(_wrap_new_InterestAccrualDate), -1);
  cInterestAccrualDate.mark = 0;
  cInterestAccrualDate.destroy = (void (*)(void *)) free_FIX_InterestAccrualDate;
  cInterestAccrualDate.trackObjects = 0;
  
  cFutSettDate2.klass = rb_define_class_under(mQuickfix, "FutSettDate2", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FutSettDate2, (void *) &cFutSettDate2);
  rb_define_alloc_func(cFutSettDate2.klass, _wrap_FutSettDate2_allocate);
  rb_define_method(cFutSettDate2.klass, "initialize", VALUEFUNC(_wrap_new_FutSettDate2), -1);
  cFutSettDate2.mark = 0;
  cFutSettDate2.destroy = (void (*)(void *)) free_FIX_FutSettDate2;
  cFutSettDate2.trackObjects = 0;
  
  cNoClearingInstructions.klass = rb_define_class_under(mQuickfix, "NoClearingInstructions", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoClearingInstructions, (void *) &cNoClearingInstructions);
  rb_define_alloc_func(cNoClearingInstructions.klass, _wrap_NoClearingInstructions_allocate);
  rb_define_method(cNoClearingInstructions.klass, "initialize", VALUEFUNC(_wrap_new_NoClearingInstructions), -1);
  cNoClearingInstructions.mark = 0;
  cNoClearingInstructions.destroy = (void (*)(void *)) free_FIX_NoClearingInstructions;
  cNoClearingInstructions.trackObjects = 0;
  
  cUnderlyingCurrency.klass = rb_define_class_under(mQuickfix, "UnderlyingCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCurrency, (void *) &cUnderlyingCurrency);
  rb_define_alloc_func(cUnderlyingCurrency.klass, _wrap_UnderlyingCurrency_allocate);
  rb_define_method(cUnderlyingCurrency.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCurrency), -1);
  cUnderlyingCurrency.mark = 0;
  cUnderlyingCurrency.destroy = (void (*)(void *)) free_FIX_UnderlyingCurrency;
  cUnderlyingCurrency.trackObjects = 0;
  
  cLegInterestAccrualDate.klass = rb_define_class_under(mQuickfix, "LegInterestAccrualDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegInterestAccrualDate, (void *) &cLegInterestAccrualDate);
  rb_define_alloc_func(cLegInterestAccrualDate.klass, _wrap_LegInterestAccrualDate_allocate);
  rb_define_method(cLegInterestAccrualDate.klass, "initialize", VALUEFUNC(_wrap_new_LegInterestAccrualDate), -1);
  cLegInterestAccrualDate.mark = 0;
  cLegInterestAccrualDate.destroy = (void (*)(void *)) free_FIX_LegInterestAccrualDate;
  cLegInterestAccrualDate.trackObjects = 0;
  
  cNewPassword.klass = rb_define_class_under(mQuickfix, "NewPassword", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewPassword, (void *) &cNewPassword);
  rb_define_alloc_func(cNewPassword.klass, _wrap_NewPassword_allocate);
  rb_define_method(cNewPassword.klass, "initialize", VALUEFUNC(_wrap_new_NewPassword), -1);
  cNewPassword.mark = 0;
  cNewPassword.destroy = (void (*)(void *)) free_FIX_NewPassword;
  cNewPassword.trackObjects = 0;
  
  cRedemptionDate.klass = rb_define_class_under(mQuickfix, "RedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RedemptionDate, (void *) &cRedemptionDate);
  rb_define_alloc_func(cRedemptionDate.klass, _wrap_RedemptionDate_allocate);
  rb_define_method(cRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_RedemptionDate), -1);
  cRedemptionDate.mark = 0;
  cRedemptionDate.destroy = (void (*)(void *)) free_FIX_RedemptionDate;
  cRedemptionDate.trackObjects = 0;
  
  cRefApplLastSeqNum.klass = rb_define_class_under(mQuickfix, "RefApplLastSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplLastSeqNum, (void *) &cRefApplLastSeqNum);
  rb_define_alloc_func(cRefApplLastSeqNum.klass, _wrap_RefApplLastSeqNum_allocate);
  rb_define_method(cRefApplLastSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_RefApplLastSeqNum), -1);
  cRefApplLastSeqNum.mark = 0;
  cRefApplLastSeqNum.destroy = (void (*)(void *)) free_FIX_RefApplLastSeqNum;
  cRefApplLastSeqNum.trackObjects = 0;
  
  cStartCash.klass = rb_define_class_under(mQuickfix, "StartCash", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartCash, (void *) &cStartCash);
  rb_define_alloc_func(cStartCash.klass, _wrap_StartCash_allocate);
  rb_define_method(cStartCash.klass, "initialize", VALUEFUNC(_wrap_new_StartCash), -1);
  cStartCash.mark = 0;
  cStartCash.destroy = (void (*)(void *)) free_FIX_StartCash;
  cStartCash.trackObjects = 0;
  
  cMaxMessageSize.klass = rb_define_class_under(mQuickfix, "MaxMessageSize", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxMessageSize, (void *) &cMaxMessageSize);
  rb_define_alloc_func(cMaxMessageSize.klass, _wrap_MaxMessageSize_allocate);
  rb_define_method(cMaxMessageSize.klass, "initialize", VALUEFUNC(_wrap_new_MaxMessageSize), -1);
  cMaxMessageSize.mark = 0;
  cMaxMessageSize.destroy = (void (*)(void *)) free_FIX_MaxMessageSize;
  cMaxMessageSize.trackObjects = 0;
  
  cOfferForwardPoints.klass = rb_define_class_under(mQuickfix, "OfferForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferForwardPoints, (void *) &cOfferForwardPoints);
  rb_define_alloc_func(cOfferForwardPoints.klass, _wrap_OfferForwardPoints_allocate);
  rb_define_method(cOfferForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_OfferForwardPoints), -1);
  cOfferForwardPoints.mark = 0;
  cOfferForwardPoints.destroy = (void (*)(void *)) free_FIX_OfferForwardPoints;
  cOfferForwardPoints.trackObjects = 0;
  
  cIOIQty.klass = rb_define_class_under(mQuickfix, "IOIQty", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIQty, (void *) &cIOIQty);
  rb_define_alloc_func(cIOIQty.klass, _wrap_IOIQty_allocate);
  rb_define_method(cIOIQty.klass, "initialize", VALUEFUNC(_wrap_new_IOIQty), -1);
  cIOIQty.mark = 0;
  cIOIQty.destroy = (void (*)(void *)) free_FIX_IOIQty;
  cIOIQty.trackObjects = 0;
  
  cLastQty.klass = rb_define_class_under(mQuickfix, "LastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastQty, (void *) &cLastQty);
  rb_define_alloc_func(cLastQty.klass, _wrap_LastQty_allocate);
  rb_define_method(cLastQty.klass, "initialize", VALUEFUNC(_wrap_new_LastQty), -1);
  cLastQty.mark = 0;
  cLastQty.destroy = (void (*)(void *)) free_FIX_LastQty;
  cLastQty.trackObjects = 0;
  
  cApplResponseError.klass = rb_define_class_under(mQuickfix, "ApplResponseError", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResponseError, (void *) &cApplResponseError);
  rb_define_alloc_func(cApplResponseError.klass, _wrap_ApplResponseError_allocate);
  rb_define_method(cApplResponseError.klass, "initialize", VALUEFUNC(_wrap_new_ApplResponseError), -1);
  cApplResponseError.mark = 0;
  cApplResponseError.destroy = (void (*)(void *)) free_FIX_ApplResponseError;
  cApplResponseError.trackObjects = 0;
  
  cUnderlyingLegSecurityType.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityType, (void *) &cUnderlyingLegSecurityType);
  rb_define_alloc_func(cUnderlyingLegSecurityType.klass, _wrap_UnderlyingLegSecurityType_allocate);
  rb_define_method(cUnderlyingLegSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityType), -1);
  cUnderlyingLegSecurityType.mark = 0;
  cUnderlyingLegSecurityType.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityType;
  cUnderlyingLegSecurityType.trackObjects = 0;
  
  cDerivativePriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "DerivativePriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasure, (void *) &cDerivativePriceUnitOfMeasure);
  rb_define_alloc_func(cDerivativePriceUnitOfMeasure.klass, _wrap_DerivativePriceUnitOfMeasure_allocate);
  rb_define_method(cDerivativePriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePriceUnitOfMeasure), -1);
  cDerivativePriceUnitOfMeasure.mark = 0;
  cDerivativePriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_DerivativePriceUnitOfMeasure;
  cDerivativePriceUnitOfMeasure.trackObjects = 0;
  
  cTriggerPriceDirection.klass = rb_define_class_under(mQuickfix, "TriggerPriceDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPriceDirection, (void *) &cTriggerPriceDirection);
  rb_define_alloc_func(cTriggerPriceDirection.klass, _wrap_TriggerPriceDirection_allocate);
  rb_define_method(cTriggerPriceDirection.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPriceDirection), -1);
  cTriggerPriceDirection.mark = 0;
  cTriggerPriceDirection.destroy = (void (*)(void *)) free_FIX_TriggerPriceDirection;
  cTriggerPriceDirection.trackObjects = 0;
  
  cPositionCurrency.klass = rb_define_class_under(mQuickfix, "PositionCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PositionCurrency, (void *) &cPositionCurrency);
  rb_define_alloc_func(cPositionCurrency.klass, _wrap_PositionCurrency_allocate);
  rb_define_method(cPositionCurrency.klass, "initialize", VALUEFUNC(_wrap_new_PositionCurrency), -1);
  cPositionCurrency.mark = 0;
  cPositionCurrency.destroy = (void (*)(void *)) free_FIX_PositionCurrency;
  cPositionCurrency.trackObjects = 0;
  
  cMessageEventSource.klass = rb_define_class_under(mQuickfix, "MessageEventSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageEventSource, (void *) &cMessageEventSource);
  rb_define_alloc_func(cMessageEventSource.klass, _wrap_MessageEventSource_allocate);
  rb_define_method(cMessageEventSource.klass, "initialize", VALUEFUNC(_wrap_new_MessageEventSource), -1);
  cMessageEventSource.mark = 0;
  cMessageEventSource.destroy = (void (*)(void *)) free_FIX_MessageEventSource;
  cMessageEventSource.trackObjects = 0;
  
  cCollInquiryID.klass = rb_define_class_under(mQuickfix, "CollInquiryID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollInquiryID, (void *) &cCollInquiryID);
  rb_define_alloc_func(cCollInquiryID.klass, _wrap_CollInquiryID_allocate);
  rb_define_method(cCollInquiryID.klass, "initialize", VALUEFUNC(_wrap_new_CollInquiryID), -1);
  cCollInquiryID.mark = 0;
  cCollInquiryID.destroy = (void (*)(void *)) free_FIX_CollInquiryID;
  cCollInquiryID.trackObjects = 0;
  
  cUnderlyingStartValue.klass = rb_define_class_under(mQuickfix, "UnderlyingStartValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStartValue, (void *) &cUnderlyingStartValue);
  rb_define_alloc_func(cUnderlyingStartValue.klass, _wrap_UnderlyingStartValue_allocate);
  rb_define_method(cUnderlyingStartValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStartValue), -1);
  cUnderlyingStartValue.mark = 0;
  cUnderlyingStartValue.destroy = (void (*)(void *)) free_FIX_UnderlyingStartValue;
  cUnderlyingStartValue.trackObjects = 0;
  
  cLastLiquidityInd.klass = rb_define_class_under(mQuickfix, "LastLiquidityInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastLiquidityInd, (void *) &cLastLiquidityInd);
  rb_define_alloc_func(cLastLiquidityInd.klass, _wrap_LastLiquidityInd_allocate);
  rb_define_method(cLastLiquidityInd.klass, "initialize", VALUEFUNC(_wrap_new_LastLiquidityInd), -1);
  cLastLiquidityInd.mark = 0;
  cLastLiquidityInd.destroy = (void (*)(void *)) free_FIX_LastLiquidityInd;
  cLastLiquidityInd.trackObjects = 0;
  
  cSecurityID.klass = rb_define_class_under(mQuickfix, "SecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityID, (void *) &cSecurityID);
  rb_define_alloc_func(cSecurityID.klass, _wrap_SecurityID_allocate);
  rb_define_method(cSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityID), -1);
  cSecurityID.mark = 0;
  cSecurityID.destroy = (void (*)(void *)) free_FIX_SecurityID;
  cSecurityID.trackObjects = 0;
  
  cNoMDEntries.klass = rb_define_class_under(mQuickfix, "NoMDEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMDEntries, (void *) &cNoMDEntries);
  rb_define_alloc_func(cNoMDEntries.klass, _wrap_NoMDEntries_allocate);
  rb_define_method(cNoMDEntries.klass, "initialize", VALUEFUNC(_wrap_new_NoMDEntries), -1);
  cNoMDEntries.mark = 0;
  cNoMDEntries.destroy = (void (*)(void *)) free_FIX_NoMDEntries;
  cNoMDEntries.trackObjects = 0;
  
  cNoPartyListResponseTypes.klass = rb_define_class_under(mQuickfix, "NoPartyListResponseTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartyListResponseTypes, (void *) &cNoPartyListResponseTypes);
  rb_define_alloc_func(cNoPartyListResponseTypes.klass, _wrap_NoPartyListResponseTypes_allocate);
  rb_define_method(cNoPartyListResponseTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoPartyListResponseTypes), -1);
  cNoPartyListResponseTypes.mark = 0;
  cNoPartyListResponseTypes.destroy = (void (*)(void *)) free_FIX_NoPartyListResponseTypes;
  cNoPartyListResponseTypes.trackObjects = 0;
  
  cStrikePriceDeterminationMethod.klass = rb_define_class_under(mQuickfix, "StrikePriceDeterminationMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePriceDeterminationMethod, (void *) &cStrikePriceDeterminationMethod);
  rb_define_alloc_func(cStrikePriceDeterminationMethod.klass, _wrap_StrikePriceDeterminationMethod_allocate);
  rb_define_method(cStrikePriceDeterminationMethod.klass, "initialize", VALUEFUNC(_wrap_new_StrikePriceDeterminationMethod), -1);
  cStrikePriceDeterminationMethod.mark = 0;
  cStrikePriceDeterminationMethod.destroy = (void (*)(void *)) free_FIX_StrikePriceDeterminationMethod;
  cStrikePriceDeterminationMethod.trackObjects = 0;
  
  cEndDate.klass = rb_define_class_under(mQuickfix, "EndDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndDate, (void *) &cEndDate);
  rb_define_alloc_func(cEndDate.klass, _wrap_EndDate_allocate);
  rb_define_method(cEndDate.klass, "initialize", VALUEFUNC(_wrap_new_EndDate), -1);
  cEndDate.mark = 0;
  cEndDate.destroy = (void (*)(void *)) free_FIX_EndDate;
  cEndDate.trackObjects = 0;
  
  cCashOutstanding.klass = rb_define_class_under(mQuickfix, "CashOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashOutstanding, (void *) &cCashOutstanding);
  rb_define_alloc_func(cCashOutstanding.klass, _wrap_CashOutstanding_allocate);
  rb_define_method(cCashOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_CashOutstanding), -1);
  cCashOutstanding.mark = 0;
  cCashOutstanding.destroy = (void (*)(void *)) free_FIX_CashOutstanding;
  cCashOutstanding.trackObjects = 0;
  
  cMDReqID.klass = rb_define_class_under(mQuickfix, "MDReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDReqID, (void *) &cMDReqID);
  rb_define_alloc_func(cMDReqID.klass, _wrap_MDReqID_allocate);
  rb_define_method(cMDReqID.klass, "initialize", VALUEFUNC(_wrap_new_MDReqID), -1);
  cMDReqID.mark = 0;
  cMDReqID.destroy = (void (*)(void *)) free_FIX_MDReqID;
  cMDReqID.trackObjects = 0;
  
  cIOIRefID.klass = rb_define_class_under(mQuickfix, "IOIRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIRefID, (void *) &cIOIRefID);
  rb_define_alloc_func(cIOIRefID.klass, _wrap_IOIRefID_allocate);
  rb_define_method(cIOIRefID.klass, "initialize", VALUEFUNC(_wrap_new_IOIRefID), -1);
  cIOIRefID.mark = 0;
  cIOIRefID.destroy = (void (*)(void *)) free_FIX_IOIRefID;
  cIOIRefID.trackObjects = 0;
  
  cNoContextPartyIDs.klass = rb_define_class_under(mQuickfix, "NoContextPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoContextPartyIDs, (void *) &cNoContextPartyIDs);
  rb_define_alloc_func(cNoContextPartyIDs.klass, _wrap_NoContextPartyIDs_allocate);
  rb_define_method(cNoContextPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoContextPartyIDs), -1);
  cNoContextPartyIDs.mark = 0;
  cNoContextPartyIDs.destroy = (void (*)(void *)) free_FIX_NoContextPartyIDs;
  cNoContextPartyIDs.trackObjects = 0;
  
  cTargetStrategy.klass = rb_define_class_under(mQuickfix, "TargetStrategy", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetStrategy, (void *) &cTargetStrategy);
  rb_define_alloc_func(cTargetStrategy.klass, _wrap_TargetStrategy_allocate);
  rb_define_method(cTargetStrategy.klass, "initialize", VALUEFUNC(_wrap_new_TargetStrategy), -1);
  cTargetStrategy.mark = 0;
  cTargetStrategy.destroy = (void (*)(void *)) free_FIX_TargetStrategy;
  cTargetStrategy.trackObjects = 0;
  
  cConfirmRefID.klass = rb_define_class_under(mQuickfix, "ConfirmRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmRefID, (void *) &cConfirmRefID);
  rb_define_alloc_func(cConfirmRefID.klass, _wrap_ConfirmRefID_allocate);
  rb_define_method(cConfirmRefID.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmRefID), -1);
  cConfirmRefID.mark = 0;
  cConfirmRefID.destroy = (void (*)(void *)) free_FIX_ConfirmRefID;
  cConfirmRefID.trackObjects = 0;
  
  cSellerDays.klass = rb_define_class_under(mQuickfix, "SellerDays", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SellerDays, (void *) &cSellerDays);
  rb_define_alloc_func(cSellerDays.klass, _wrap_SellerDays_allocate);
  rb_define_method(cSellerDays.klass, "initialize", VALUEFUNC(_wrap_new_SellerDays), -1);
  cSellerDays.mark = 0;
  cSellerDays.destroy = (void (*)(void *)) free_FIX_SellerDays;
  cSellerDays.trackObjects = 0;
  
  cDueToRelated.klass = rb_define_class_under(mQuickfix, "DueToRelated", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DueToRelated, (void *) &cDueToRelated);
  rb_define_alloc_func(cDueToRelated.klass, _wrap_DueToRelated_allocate);
  rb_define_method(cDueToRelated.klass, "initialize", VALUEFUNC(_wrap_new_DueToRelated), -1);
  cDueToRelated.mark = 0;
  cDueToRelated.destroy = (void (*)(void *)) free_FIX_DueToRelated;
  cDueToRelated.trackObjects = 0;
  
  cSecondaryTradingReferencePrice.klass = rb_define_class_under(mQuickfix, "SecondaryTradingReferencePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradingReferencePrice, (void *) &cSecondaryTradingReferencePrice);
  rb_define_alloc_func(cSecondaryTradingReferencePrice.klass, _wrap_SecondaryTradingReferencePrice_allocate);
  rb_define_method(cSecondaryTradingReferencePrice.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradingReferencePrice), -1);
  cSecondaryTradingReferencePrice.mark = 0;
  cSecondaryTradingReferencePrice.destroy = (void (*)(void *)) free_FIX_SecondaryTradingReferencePrice;
  cSecondaryTradingReferencePrice.trackObjects = 0;
  
  cNoMDFeedTypes.klass = rb_define_class_under(mQuickfix, "NoMDFeedTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMDFeedTypes, (void *) &cNoMDFeedTypes);
  rb_define_alloc_func(cNoMDFeedTypes.klass, _wrap_NoMDFeedTypes_allocate);
  rb_define_method(cNoMDFeedTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoMDFeedTypes), -1);
  cNoMDFeedTypes.mark = 0;
  cNoMDFeedTypes.destroy = (void (*)(void *)) free_FIX_NoMDFeedTypes;
  cNoMDFeedTypes.trackObjects = 0;
  
  cUnderlyingInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubIDType, (void *) &cUnderlyingInstrumentPartySubIDType);
  rb_define_alloc_func(cUnderlyingInstrumentPartySubIDType.klass, _wrap_UnderlyingInstrumentPartySubIDType_allocate);
  rb_define_method(cUnderlyingInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartySubIDType), -1);
  cUnderlyingInstrumentPartySubIDType.mark = 0;
  cUnderlyingInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartySubIDType;
  cUnderlyingInstrumentPartySubIDType.trackObjects = 0;
  
  cTradSesCloseTime.klass = rb_define_class_under(mQuickfix, "TradSesCloseTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesCloseTime, (void *) &cTradSesCloseTime);
  rb_define_alloc_func(cTradSesCloseTime.klass, _wrap_TradSesCloseTime_allocate);
  rb_define_method(cTradSesCloseTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesCloseTime), -1);
  cTradSesCloseTime.mark = 0;
  cTradSesCloseTime.destroy = (void (*)(void *)) free_FIX_TradSesCloseTime;
  cTradSesCloseTime.trackObjects = 0;
  
  cContractSettlMonth.klass = rb_define_class_under(mQuickfix, "ContractSettlMonth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContractSettlMonth, (void *) &cContractSettlMonth);
  rb_define_alloc_func(cContractSettlMonth.klass, _wrap_ContractSettlMonth_allocate);
  rb_define_method(cContractSettlMonth.klass, "initialize", VALUEFUNC(_wrap_new_ContractSettlMonth), -1);
  cContractSettlMonth.mark = 0;
  cContractSettlMonth.destroy = (void (*)(void *)) free_FIX_ContractSettlMonth;
  cContractSettlMonth.trackObjects = 0;
  
  cDerivativeStrikePrice.klass = rb_define_class_under(mQuickfix, "DerivativeStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikePrice, (void *) &cDerivativeStrikePrice);
  rb_define_alloc_func(cDerivativeStrikePrice.klass, _wrap_DerivativeStrikePrice_allocate);
  rb_define_method(cDerivativeStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikePrice), -1);
  cDerivativeStrikePrice.mark = 0;
  cDerivativeStrikePrice.destroy = (void (*)(void *)) free_FIX_DerivativeStrikePrice;
  cDerivativeStrikePrice.trackObjects = 0;
  
  cTriggerSecurityDesc.klass = rb_define_class_under(mQuickfix, "TriggerSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSecurityDesc, (void *) &cTriggerSecurityDesc);
  rb_define_alloc_func(cTriggerSecurityDesc.klass, _wrap_TriggerSecurityDesc_allocate);
  rb_define_method(cTriggerSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSecurityDesc), -1);
  cTriggerSecurityDesc.mark = 0;
  cTriggerSecurityDesc.destroy = (void (*)(void *)) free_FIX_TriggerSecurityDesc;
  cTriggerSecurityDesc.trackObjects = 0;
  
  cUnderlyingCashType.klass = rb_define_class_under(mQuickfix, "UnderlyingCashType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCashType, (void *) &cUnderlyingCashType);
  rb_define_alloc_func(cUnderlyingCashType.klass, _wrap_UnderlyingCashType_allocate);
  rb_define_method(cUnderlyingCashType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCashType), -1);
  cUnderlyingCashType.mark = 0;
  cUnderlyingCashType.destroy = (void (*)(void *)) free_FIX_UnderlyingCashType;
  cUnderlyingCashType.trackObjects = 0;
  
  cNoMiscFees.klass = rb_define_class_under(mQuickfix, "NoMiscFees", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMiscFees, (void *) &cNoMiscFees);
  rb_define_alloc_func(cNoMiscFees.klass, _wrap_NoMiscFees_allocate);
  rb_define_method(cNoMiscFees.klass, "initialize", VALUEFUNC(_wrap_new_NoMiscFees), -1);
  cNoMiscFees.mark = 0;
  cNoMiscFees.destroy = (void (*)(void *)) free_FIX_NoMiscFees;
  cNoMiscFees.trackObjects = 0;
  
  cCustOrderCapacity.klass = rb_define_class_under(mQuickfix, "CustOrderCapacity", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustOrderCapacity, (void *) &cCustOrderCapacity);
  rb_define_alloc_func(cCustOrderCapacity.klass, _wrap_CustOrderCapacity_allocate);
  rb_define_method(cCustOrderCapacity.klass, "initialize", VALUEFUNC(_wrap_new_CustOrderCapacity), -1);
  cCustOrderCapacity.mark = 0;
  cCustOrderCapacity.destroy = (void (*)(void *)) free_FIX_CustOrderCapacity;
  cCustOrderCapacity.trackObjects = 0;
  
  cRiskSecurityExchange.klass = rb_define_class_under(mQuickfix, "RiskSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityExchange, (void *) &cRiskSecurityExchange);
  rb_define_alloc_func(cRiskSecurityExchange.klass, _wrap_RiskSecurityExchange_allocate);
  rb_define_method(cRiskSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityExchange), -1);
  cRiskSecurityExchange.mark = 0;
  cRiskSecurityExchange.destroy = (void (*)(void *)) free_FIX_RiskSecurityExchange;
  cRiskSecurityExchange.trackObjects = 0;
  
  cLegAllocSettlCurrency.klass = rb_define_class_under(mQuickfix, "LegAllocSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocSettlCurrency, (void *) &cLegAllocSettlCurrency);
  rb_define_alloc_func(cLegAllocSettlCurrency.klass, _wrap_LegAllocSettlCurrency_allocate);
  rb_define_method(cLegAllocSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocSettlCurrency), -1);
  cLegAllocSettlCurrency.mark = 0;
  cLegAllocSettlCurrency.destroy = (void (*)(void *)) free_FIX_LegAllocSettlCurrency;
  cLegAllocSettlCurrency.trackObjects = 0;
  
  cUnderlyingAdjustedQuantity.klass = rb_define_class_under(mQuickfix, "UnderlyingAdjustedQuantity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingAdjustedQuantity, (void *) &cUnderlyingAdjustedQuantity);
  rb_define_alloc_func(cUnderlyingAdjustedQuantity.klass, _wrap_UnderlyingAdjustedQuantity_allocate);
  rb_define_method(cUnderlyingAdjustedQuantity.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingAdjustedQuantity), -1);
  cUnderlyingAdjustedQuantity.mark = 0;
  cUnderlyingAdjustedQuantity.destroy = (void (*)(void *)) free_FIX_UnderlyingAdjustedQuantity;
  cUnderlyingAdjustedQuantity.trackObjects = 0;
  
  cOwnershipType.klass = rb_define_class_under(mQuickfix, "OwnershipType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OwnershipType, (void *) &cOwnershipType);
  rb_define_alloc_func(cOwnershipType.klass, _wrap_OwnershipType_allocate);
  rb_define_method(cOwnershipType.klass, "initialize", VALUEFUNC(_wrap_new_OwnershipType), -1);
  cOwnershipType.mark = 0;
  cOwnershipType.destroy = (void (*)(void *)) free_FIX_OwnershipType;
  cOwnershipType.trackObjects = 0;
  
  cMaxShow.klass = rb_define_class_under(mQuickfix, "MaxShow", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxShow, (void *) &cMaxShow);
  rb_define_alloc_func(cMaxShow.klass, _wrap_MaxShow_allocate);
  rb_define_method(cMaxShow.klass, "initialize", VALUEFUNC(_wrap_new_MaxShow), -1);
  cMaxShow.mark = 0;
  cMaxShow.destroy = (void (*)(void *)) free_FIX_MaxShow;
  cMaxShow.trackObjects = 0;
  
  cLegSecurityID.klass = rb_define_class_under(mQuickfix, "LegSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityID, (void *) &cLegSecurityID);
  rb_define_alloc_func(cLegSecurityID.klass, _wrap_LegSecurityID_allocate);
  rb_define_method(cLegSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityID), -1);
  cLegSecurityID.mark = 0;
  cLegSecurityID.destroy = (void (*)(void *)) free_FIX_LegSecurityID;
  cLegSecurityID.trackObjects = 0;
  
  cEncodedSymbol.klass = rb_define_class_under(mQuickfix, "EncodedSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSymbol, (void *) &cEncodedSymbol);
  rb_define_alloc_func(cEncodedSymbol.klass, _wrap_EncodedSymbol_allocate);
  rb_define_method(cEncodedSymbol.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSymbol), -1);
  cEncodedSymbol.mark = 0;
  cEncodedSymbol.destroy = (void (*)(void *)) free_FIX_EncodedSymbol;
  cEncodedSymbol.trackObjects = 0;
  
  cDerivativeSecurityDesc.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityDesc, (void *) &cDerivativeSecurityDesc);
  rb_define_alloc_func(cDerivativeSecurityDesc.klass, _wrap_DerivativeSecurityDesc_allocate);
  rb_define_method(cDerivativeSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityDesc), -1);
  cDerivativeSecurityDesc.mark = 0;
  cDerivativeSecurityDesc.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityDesc;
  cDerivativeSecurityDesc.trackObjects = 0;
  
  cUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "UnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnitOfMeasure, (void *) &cUnitOfMeasure);
  rb_define_alloc_func(cUnitOfMeasure.klass, _wrap_UnitOfMeasure_allocate);
  rb_define_method(cUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_UnitOfMeasure), -1);
  cUnitOfMeasure.mark = 0;
  cUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_UnitOfMeasure;
  cUnitOfMeasure.trackObjects = 0;
  
  cSecDefStatus.klass = rb_define_class_under(mQuickfix, "SecDefStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecDefStatus, (void *) &cSecDefStatus);
  rb_define_alloc_func(cSecDefStatus.klass, _wrap_SecDefStatus_allocate);
  rb_define_method(cSecDefStatus.klass, "initialize", VALUEFUNC(_wrap_new_SecDefStatus), -1);
  cSecDefStatus.mark = 0;
  cSecDefStatus.destroy = (void (*)(void *)) free_FIX_SecDefStatus;
  cSecDefStatus.trackObjects = 0;
  
  cQuantity.klass = rb_define_class_under(mQuickfix, "Quantity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Quantity, (void *) &cQuantity);
  rb_define_alloc_func(cQuantity.klass, _wrap_Quantity_allocate);
  rb_define_method(cQuantity.klass, "initialize", VALUEFUNC(_wrap_new_Quantity), -1);
  cQuantity.mark = 0;
  cQuantity.destroy = (void (*)(void *)) free_FIX_Quantity;
  cQuantity.trackObjects = 0;
  
  cNewsID.klass = rb_define_class_under(mQuickfix, "NewsID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsID, (void *) &cNewsID);
  rb_define_alloc_func(cNewsID.klass, _wrap_NewsID_allocate);
  rb_define_method(cNewsID.klass, "initialize", VALUEFUNC(_wrap_new_NewsID), -1);
  cNewsID.mark = 0;
  cNewsID.destroy = (void (*)(void *)) free_FIX_NewsID;
  cNewsID.trackObjects = 0;
  
  cUndlyInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartySubIDType, (void *) &cUndlyInstrumentPartySubIDType);
  rb_define_alloc_func(cUndlyInstrumentPartySubIDType.klass, _wrap_UndlyInstrumentPartySubIDType_allocate);
  rb_define_method(cUndlyInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartySubIDType), -1);
  cUndlyInstrumentPartySubIDType.mark = 0;
  cUndlyInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartySubIDType;
  cUndlyInstrumentPartySubIDType.trackObjects = 0;
  
  cSettleOnOpenFlag.klass = rb_define_class_under(mQuickfix, "SettleOnOpenFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettleOnOpenFlag, (void *) &cSettleOnOpenFlag);
  rb_define_alloc_func(cSettleOnOpenFlag.klass, _wrap_SettleOnOpenFlag_allocate);
  rb_define_method(cSettleOnOpenFlag.klass, "initialize", VALUEFUNC(_wrap_new_SettleOnOpenFlag), -1);
  cSettleOnOpenFlag.mark = 0;
  cSettleOnOpenFlag.destroy = (void (*)(void *)) free_FIX_SettleOnOpenFlag;
  cSettleOnOpenFlag.trackObjects = 0;
  
  cLastUpdateTime.klass = rb_define_class_under(mQuickfix, "LastUpdateTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastUpdateTime, (void *) &cLastUpdateTime);
  rb_define_alloc_func(cLastUpdateTime.klass, _wrap_LastUpdateTime_allocate);
  rb_define_method(cLastUpdateTime.klass, "initialize", VALUEFUNC(_wrap_new_LastUpdateTime), -1);
  cLastUpdateTime.mark = 0;
  cLastUpdateTime.destroy = (void (*)(void *)) free_FIX_LastUpdateTime;
  cLastUpdateTime.trackObjects = 0;
  
  cRepurchaseRate.klass = rb_define_class_under(mQuickfix, "RepurchaseRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepurchaseRate, (void *) &cRepurchaseRate);
  rb_define_alloc_func(cRepurchaseRate.klass, _wrap_RepurchaseRate_allocate);
  rb_define_method(cRepurchaseRate.klass, "initialize", VALUEFUNC(_wrap_new_RepurchaseRate), -1);
  cRepurchaseRate.mark = 0;
  cRepurchaseRate.destroy = (void (*)(void *)) free_FIX_RepurchaseRate;
  cRepurchaseRate.trackObjects = 0;
  
  cRepurchaseTerm.klass = rb_define_class_under(mQuickfix, "RepurchaseTerm", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepurchaseTerm, (void *) &cRepurchaseTerm);
  rb_define_alloc_func(cRepurchaseTerm.klass, _wrap_RepurchaseTerm_allocate);
  rb_define_method(cRepurchaseTerm.klass, "initialize", VALUEFUNC(_wrap_new_RepurchaseTerm), -1);
  cRepurchaseTerm.mark = 0;
  cRepurchaseTerm.destroy = (void (*)(void *)) free_FIX_RepurchaseTerm;
  cRepurchaseTerm.trackObjects = 0;
  
  cNestedPartyRole.klass = rb_define_class_under(mQuickfix, "NestedPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartyRole, (void *) &cNestedPartyRole);
  rb_define_alloc_func(cNestedPartyRole.klass, _wrap_NestedPartyRole_allocate);
  rb_define_method(cNestedPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartyRole), -1);
  cNestedPartyRole.mark = 0;
  cNestedPartyRole.destroy = (void (*)(void *)) free_FIX_NestedPartyRole;
  cNestedPartyRole.trackObjects = 0;
  
  cSecondaryExecID.klass = rb_define_class_under(mQuickfix, "SecondaryExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryExecID, (void *) &cSecondaryExecID);
  rb_define_alloc_func(cSecondaryExecID.klass, _wrap_SecondaryExecID_allocate);
  rb_define_method(cSecondaryExecID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryExecID), -1);
  cSecondaryExecID.mark = 0;
  cSecondaryExecID.destroy = (void (*)(void *)) free_FIX_SecondaryExecID;
  cSecondaryExecID.trackObjects = 0;
  
  cPool.klass = rb_define_class_under(mQuickfix, "Pool", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Pool, (void *) &cPool);
  rb_define_alloc_func(cPool.klass, _wrap_Pool_allocate);
  rb_define_method(cPool.klass, "initialize", VALUEFUNC(_wrap_new_Pool), -1);
  cPool.mark = 0;
  cPool.destroy = (void (*)(void *)) free_FIX_Pool;
  cPool.trackObjects = 0;
  
  cNoTickRules.klass = rb_define_class_under(mQuickfix, "NoTickRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTickRules, (void *) &cNoTickRules);
  rb_define_alloc_func(cNoTickRules.klass, _wrap_NoTickRules_allocate);
  rb_define_method(cNoTickRules.klass, "initialize", VALUEFUNC(_wrap_new_NoTickRules), -1);
  cNoTickRules.mark = 0;
  cNoTickRules.destroy = (void (*)(void *)) free_FIX_NoTickRules;
  cNoTickRules.trackObjects = 0;
  
  cVolatility.klass = rb_define_class_under(mQuickfix, "Volatility", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Volatility, (void *) &cVolatility);
  rb_define_alloc_func(cVolatility.klass, _wrap_Volatility_allocate);
  rb_define_method(cVolatility.klass, "initialize", VALUEFUNC(_wrap_new_Volatility), -1);
  cVolatility.mark = 0;
  cVolatility.destroy = (void (*)(void *)) free_FIX_Volatility;
  cVolatility.trackObjects = 0;
  
  cPctAtRisk.klass = rb_define_class_under(mQuickfix, "PctAtRisk", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PctAtRisk, (void *) &cPctAtRisk);
  rb_define_alloc_func(cPctAtRisk.klass, _wrap_PctAtRisk_allocate);
  rb_define_method(cPctAtRisk.klass, "initialize", VALUEFUNC(_wrap_new_PctAtRisk), -1);
  cPctAtRisk.mark = 0;
  cPctAtRisk.destroy = (void (*)(void *)) free_FIX_PctAtRisk;
  cPctAtRisk.trackObjects = 0;
  
  cUnderlyingSecurityExchange.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityExchange, (void *) &cUnderlyingSecurityExchange);
  rb_define_alloc_func(cUnderlyingSecurityExchange.klass, _wrap_UnderlyingSecurityExchange_allocate);
  rb_define_method(cUnderlyingSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityExchange), -1);
  cUnderlyingSecurityExchange.mark = 0;
  cUnderlyingSecurityExchange.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityExchange;
  cUnderlyingSecurityExchange.trackObjects = 0;
  
  cLegStrikePrice.klass = rb_define_class_under(mQuickfix, "LegStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStrikePrice, (void *) &cLegStrikePrice);
  rb_define_alloc_func(cLegStrikePrice.klass, _wrap_LegStrikePrice_allocate);
  rb_define_method(cLegStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_LegStrikePrice), -1);
  cLegStrikePrice.mark = 0;
  cLegStrikePrice.destroy = (void (*)(void *)) free_FIX_LegStrikePrice;
  cLegStrikePrice.trackObjects = 0;
  
  cSettlmntTyp.klass = rb_define_class_under(mQuickfix, "SettlmntTyp", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlmntTyp, (void *) &cSettlmntTyp);
  rb_define_alloc_func(cSettlmntTyp.klass, _wrap_SettlmntTyp_allocate);
  rb_define_method(cSettlmntTyp.klass, "initialize", VALUEFUNC(_wrap_new_SettlmntTyp), -1);
  cSettlmntTyp.mark = 0;
  cSettlmntTyp.destroy = (void (*)(void *)) free_FIX_SettlmntTyp;
  cSettlmntTyp.trackObjects = 0;
  
  cTradePublishIndicator.klass = rb_define_class_under(mQuickfix, "TradePublishIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradePublishIndicator, (void *) &cTradePublishIndicator);
  rb_define_alloc_func(cTradePublishIndicator.klass, _wrap_TradePublishIndicator_allocate);
  rb_define_method(cTradePublishIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TradePublishIndicator), -1);
  cTradePublishIndicator.mark = 0;
  cTradePublishIndicator.destroy = (void (*)(void *)) free_FIX_TradePublishIndicator;
  cTradePublishIndicator.trackObjects = 0;
  
  cApplResponseType.klass = rb_define_class_under(mQuickfix, "ApplResponseType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResponseType, (void *) &cApplResponseType);
  rb_define_alloc_func(cApplResponseType.klass, _wrap_ApplResponseType_allocate);
  rb_define_method(cApplResponseType.klass, "initialize", VALUEFUNC(_wrap_new_ApplResponseType), -1);
  cApplResponseType.mark = 0;
  cApplResponseType.destroy = (void (*)(void *)) free_FIX_ApplResponseType;
  cApplResponseType.trackObjects = 0;
  
  cMDSubBookType.klass = rb_define_class_under(mQuickfix, "MDSubBookType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDSubBookType, (void *) &cMDSubBookType);
  rb_define_alloc_func(cMDSubBookType.klass, _wrap_MDSubBookType_allocate);
  rb_define_method(cMDSubBookType.klass, "initialize", VALUEFUNC(_wrap_new_MDSubBookType), -1);
  cMDSubBookType.mark = 0;
  cMDSubBookType.destroy = (void (*)(void *)) free_FIX_MDSubBookType;
  cMDSubBookType.trackObjects = 0;
  
  cUsername.klass = rb_define_class_under(mQuickfix, "Username", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Username, (void *) &cUsername);
  rb_define_alloc_func(cUsername.klass, _wrap_Username_allocate);
  rb_define_method(cUsername.klass, "initialize", VALUEFUNC(_wrap_new_Username), -1);
  cUsername.mark = 0;
  cUsername.destroy = (void (*)(void *)) free_FIX_Username;
  cUsername.trackObjects = 0;
  
  cStandInstDbType.klass = rb_define_class_under(mQuickfix, "StandInstDbType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StandInstDbType, (void *) &cStandInstDbType);
  rb_define_alloc_func(cStandInstDbType.klass, _wrap_StandInstDbType_allocate);
  rb_define_method(cStandInstDbType.klass, "initialize", VALUEFUNC(_wrap_new_StandInstDbType), -1);
  cStandInstDbType.mark = 0;
  cStandInstDbType.destroy = (void (*)(void *)) free_FIX_StandInstDbType;
  cStandInstDbType.trackObjects = 0;
  
  cRelatedContextPartyIDSource.klass = rb_define_class_under(mQuickfix, "RelatedContextPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedContextPartyIDSource, (void *) &cRelatedContextPartyIDSource);
  rb_define_alloc_func(cRelatedContextPartyIDSource.klass, _wrap_RelatedContextPartyIDSource_allocate);
  rb_define_method(cRelatedContextPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RelatedContextPartyIDSource), -1);
  cRelatedContextPartyIDSource.mark = 0;
  cRelatedContextPartyIDSource.destroy = (void (*)(void *)) free_FIX_RelatedContextPartyIDSource;
  cRelatedContextPartyIDSource.trackObjects = 0;
  
  cQuoteEntryStatus.klass = rb_define_class_under(mQuickfix, "QuoteEntryStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteEntryStatus, (void *) &cQuoteEntryStatus);
  rb_define_alloc_func(cQuoteEntryStatus.klass, _wrap_QuoteEntryStatus_allocate);
  rb_define_method(cQuoteEntryStatus.klass, "initialize", VALUEFUNC(_wrap_new_QuoteEntryStatus), -1);
  cQuoteEntryStatus.mark = 0;
  cQuoteEntryStatus.destroy = (void (*)(void *)) free_FIX_QuoteEntryStatus;
  cQuoteEntryStatus.trackObjects = 0;
  
  cTriggerPriceType.klass = rb_define_class_under(mQuickfix, "TriggerPriceType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPriceType, (void *) &cTriggerPriceType);
  rb_define_alloc_func(cTriggerPriceType.klass, _wrap_TriggerPriceType_allocate);
  rb_define_method(cTriggerPriceType.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPriceType), -1);
  cTriggerPriceType.mark = 0;
  cTriggerPriceType.destroy = (void (*)(void *)) free_FIX_TriggerPriceType;
  cTriggerPriceType.trackObjects = 0;
  
  cSideTrdSubTyp.klass = rb_define_class_under(mQuickfix, "SideTrdSubTyp", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdSubTyp, (void *) &cSideTrdSubTyp);
  rb_define_alloc_func(cSideTrdSubTyp.klass, _wrap_SideTrdSubTyp_allocate);
  rb_define_method(cSideTrdSubTyp.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdSubTyp), -1);
  cSideTrdSubTyp.mark = 0;
  cSideTrdSubTyp.destroy = (void (*)(void *)) free_FIX_SideTrdSubTyp;
  cSideTrdSubTyp.trackObjects = 0;
  
  cUnderlyingTradingSessionSubID.klass = rb_define_class_under(mQuickfix, "UnderlyingTradingSessionSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingTradingSessionSubID, (void *) &cUnderlyingTradingSessionSubID);
  rb_define_alloc_func(cUnderlyingTradingSessionSubID.klass, _wrap_UnderlyingTradingSessionSubID_allocate);
  rb_define_method(cUnderlyingTradingSessionSubID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingTradingSessionSubID), -1);
  cUnderlyingTradingSessionSubID.mark = 0;
  cUnderlyingTradingSessionSubID.destroy = (void (*)(void *)) free_FIX_UnderlyingTradingSessionSubID;
  cUnderlyingTradingSessionSubID.trackObjects = 0;
  
  cSettlInstReqRejCode.klass = rb_define_class_under(mQuickfix, "SettlInstReqRejCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstReqRejCode, (void *) &cSettlInstReqRejCode);
  rb_define_alloc_func(cSettlInstReqRejCode.klass, _wrap_SettlInstReqRejCode_allocate);
  rb_define_method(cSettlInstReqRejCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstReqRejCode), -1);
  cSettlInstReqRejCode.mark = 0;
  cSettlInstReqRejCode.destroy = (void (*)(void *)) free_FIX_SettlInstReqRejCode;
  cSettlInstReqRejCode.trackObjects = 0;
  
  cMktBidPx.klass = rb_define_class_under(mQuickfix, "MktBidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MktBidPx, (void *) &cMktBidPx);
  rb_define_alloc_func(cMktBidPx.klass, _wrap_MktBidPx_allocate);
  rb_define_method(cMktBidPx.klass, "initialize", VALUEFUNC(_wrap_new_MktBidPx), -1);
  cMktBidPx.mark = 0;
  cMktBidPx.destroy = (void (*)(void *)) free_FIX_MktBidPx;
  cMktBidPx.trackObjects = 0;
  
  cUnderlyingLegSymbol.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSymbol, (void *) &cUnderlyingLegSymbol);
  rb_define_alloc_func(cUnderlyingLegSymbol.klass, _wrap_UnderlyingLegSymbol_allocate);
  rb_define_method(cUnderlyingLegSymbol.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSymbol), -1);
  cUnderlyingLegSymbol.mark = 0;
  cUnderlyingLegSymbol.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSymbol;
  cUnderlyingLegSymbol.trackObjects = 0;
  
  cStrikeValue.klass = rb_define_class_under(mQuickfix, "StrikeValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikeValue, (void *) &cStrikeValue);
  rb_define_alloc_func(cStrikeValue.klass, _wrap_StrikeValue_allocate);
  rb_define_method(cStrikeValue.klass, "initialize", VALUEFUNC(_wrap_new_StrikeValue), -1);
  cStrikeValue.mark = 0;
  cStrikeValue.destroy = (void (*)(void *)) free_FIX_StrikeValue;
  cStrikeValue.trackObjects = 0;
  
  cUrgency.klass = rb_define_class_under(mQuickfix, "Urgency", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Urgency, (void *) &cUrgency);
  rb_define_alloc_func(cUrgency.klass, _wrap_Urgency_allocate);
  rb_define_method(cUrgency.klass, "initialize", VALUEFUNC(_wrap_new_Urgency), -1);
  cUrgency.mark = 0;
  cUrgency.destroy = (void (*)(void *)) free_FIX_Urgency;
  cUrgency.trackObjects = 0;
  
  cAllocID.klass = rb_define_class_under(mQuickfix, "AllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocID, (void *) &cAllocID);
  rb_define_alloc_func(cAllocID.klass, _wrap_AllocID_allocate);
  rb_define_method(cAllocID.klass, "initialize", VALUEFUNC(_wrap_new_AllocID), -1);
  cAllocID.mark = 0;
  cAllocID.destroy = (void (*)(void *)) free_FIX_AllocID;
  cAllocID.trackObjects = 0;
  
  cNoPartyList.klass = rb_define_class_under(mQuickfix, "NoPartyList", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartyList, (void *) &cNoPartyList);
  rb_define_alloc_func(cNoPartyList.klass, _wrap_NoPartyList_allocate);
  rb_define_method(cNoPartyList.klass, "initialize", VALUEFUNC(_wrap_new_NoPartyList), -1);
  cNoPartyList.mark = 0;
  cNoPartyList.destroy = (void (*)(void *)) free_FIX_NoPartyList;
  cNoPartyList.trackObjects = 0;
  
  cUnderlyingDeliveryAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingDeliveryAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingDeliveryAmount, (void *) &cUnderlyingDeliveryAmount);
  rb_define_alloc_func(cUnderlyingDeliveryAmount.klass, _wrap_UnderlyingDeliveryAmount_allocate);
  rb_define_method(cUnderlyingDeliveryAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingDeliveryAmount), -1);
  cUnderlyingDeliveryAmount.mark = 0;
  cUnderlyingDeliveryAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingDeliveryAmount;
  cUnderlyingDeliveryAmount.trackObjects = 0;
  
  cSideQty.klass = rb_define_class_under(mQuickfix, "SideQty", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideQty, (void *) &cSideQty);
  rb_define_alloc_func(cSideQty.klass, _wrap_SideQty_allocate);
  rb_define_method(cSideQty.klass, "initialize", VALUEFUNC(_wrap_new_SideQty), -1);
  cSideQty.mark = 0;
  cSideQty.destroy = (void (*)(void *)) free_FIX_SideQty;
  cSideQty.trackObjects = 0;
  
  cCollAsgnTransType.klass = rb_define_class_under(mQuickfix, "CollAsgnTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnTransType, (void *) &cCollAsgnTransType);
  rb_define_alloc_func(cCollAsgnTransType.klass, _wrap_CollAsgnTransType_allocate);
  rb_define_method(cCollAsgnTransType.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnTransType), -1);
  cCollAsgnTransType.mark = 0;
  cCollAsgnTransType.destroy = (void (*)(void *)) free_FIX_CollAsgnTransType;
  cCollAsgnTransType.trackObjects = 0;
  
  cThresholdAmount.klass = rb_define_class_under(mQuickfix, "ThresholdAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ThresholdAmount, (void *) &cThresholdAmount);
  rb_define_alloc_func(cThresholdAmount.klass, _wrap_ThresholdAmount_allocate);
  rb_define_method(cThresholdAmount.klass, "initialize", VALUEFUNC(_wrap_new_ThresholdAmount), -1);
  cThresholdAmount.mark = 0;
  cThresholdAmount.destroy = (void (*)(void *)) free_FIX_ThresholdAmount;
  cThresholdAmount.trackObjects = 0;
  
  cDefBidSize.klass = rb_define_class_under(mQuickfix, "DefBidSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefBidSize, (void *) &cDefBidSize);
  rb_define_alloc_func(cDefBidSize.klass, _wrap_DefBidSize_allocate);
  rb_define_method(cDefBidSize.klass, "initialize", VALUEFUNC(_wrap_new_DefBidSize), -1);
  cDefBidSize.mark = 0;
  cDefBidSize.destroy = (void (*)(void *)) free_FIX_DefBidSize;
  cDefBidSize.trackObjects = 0;
  
  cLegStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "LegStateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStateOrProvinceOfIssue, (void *) &cLegStateOrProvinceOfIssue);
  rb_define_alloc_func(cLegStateOrProvinceOfIssue.klass, _wrap_LegStateOrProvinceOfIssue_allocate);
  rb_define_method(cLegStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LegStateOrProvinceOfIssue), -1);
  cLegStateOrProvinceOfIssue.mark = 0;
  cLegStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_LegStateOrProvinceOfIssue;
  cLegStateOrProvinceOfIssue.trackObjects = 0;
  
  cPaymentMethod.klass = rb_define_class_under(mQuickfix, "PaymentMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PaymentMethod, (void *) &cPaymentMethod);
  rb_define_alloc_func(cPaymentMethod.klass, _wrap_PaymentMethod_allocate);
  rb_define_method(cPaymentMethod.klass, "initialize", VALUEFUNC(_wrap_new_PaymentMethod), -1);
  cPaymentMethod.mark = 0;
  cPaymentMethod.destroy = (void (*)(void *)) free_FIX_PaymentMethod;
  cPaymentMethod.trackObjects = 0;
  
  cRiskCouponRate.klass = rb_define_class_under(mQuickfix, "RiskCouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskCouponRate, (void *) &cRiskCouponRate);
  rb_define_alloc_func(cRiskCouponRate.klass, _wrap_RiskCouponRate_allocate);
  rb_define_method(cRiskCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_RiskCouponRate), -1);
  cRiskCouponRate.mark = 0;
  cRiskCouponRate.destroy = (void (*)(void *)) free_FIX_RiskCouponRate;
  cRiskCouponRate.trackObjects = 0;
  
  cUnderlyingLegOptAttribute.klass = rb_define_class_under(mQuickfix, "UnderlyingLegOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegOptAttribute, (void *) &cUnderlyingLegOptAttribute);
  rb_define_alloc_func(cUnderlyingLegOptAttribute.klass, _wrap_UnderlyingLegOptAttribute_allocate);
  rb_define_method(cUnderlyingLegOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegOptAttribute), -1);
  cUnderlyingLegOptAttribute.mark = 0;
  cUnderlyingLegOptAttribute.destroy = (void (*)(void *)) free_FIX_UnderlyingLegOptAttribute;
  cUnderlyingLegOptAttribute.trackObjects = 0;
  
  cLegVolatility.klass = rb_define_class_under(mQuickfix, "LegVolatility", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegVolatility, (void *) &cLegVolatility);
  rb_define_alloc_func(cLegVolatility.klass, _wrap_LegVolatility_allocate);
  rb_define_method(cLegVolatility.klass, "initialize", VALUEFUNC(_wrap_new_LegVolatility), -1);
  cLegVolatility.mark = 0;
  cLegVolatility.destroy = (void (*)(void *)) free_FIX_LegVolatility;
  cLegVolatility.trackObjects = 0;
  
  cDerivativeInstrAttribType.klass = rb_define_class_under(mQuickfix, "DerivativeInstrAttribType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrAttribType, (void *) &cDerivativeInstrAttribType);
  rb_define_alloc_func(cDerivativeInstrAttribType.klass, _wrap_DerivativeInstrAttribType_allocate);
  rb_define_method(cDerivativeInstrAttribType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrAttribType), -1);
  cDerivativeInstrAttribType.mark = 0;
  cDerivativeInstrAttribType.destroy = (void (*)(void *)) free_FIX_DerivativeInstrAttribType;
  cDerivativeInstrAttribType.trackObjects = 0;
  
  cDerivativeUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "DerivativeUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeUnitOfMeasureQty, (void *) &cDerivativeUnitOfMeasureQty);
  rb_define_alloc_func(cDerivativeUnitOfMeasureQty.klass, _wrap_DerivativeUnitOfMeasureQty_allocate);
  rb_define_method(cDerivativeUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeUnitOfMeasureQty), -1);
  cDerivativeUnitOfMeasureQty.mark = 0;
  cDerivativeUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_DerivativeUnitOfMeasureQty;
  cDerivativeUnitOfMeasureQty.trackObjects = 0;
  
  cNoStatsIndicators.klass = rb_define_class_under(mQuickfix, "NoStatsIndicators", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStatsIndicators, (void *) &cNoStatsIndicators);
  rb_define_alloc_func(cNoStatsIndicators.klass, _wrap_NoStatsIndicators_allocate);
  rb_define_method(cNoStatsIndicators.klass, "initialize", VALUEFUNC(_wrap_new_NoStatsIndicators), -1);
  cNoStatsIndicators.mark = 0;
  cNoStatsIndicators.destroy = (void (*)(void *)) free_FIX_NoStatsIndicators;
  cNoStatsIndicators.trackObjects = 0;
  
  cTriggerPriceTypeScope.klass = rb_define_class_under(mQuickfix, "TriggerPriceTypeScope", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPriceTypeScope, (void *) &cTriggerPriceTypeScope);
  rb_define_alloc_func(cTriggerPriceTypeScope.klass, _wrap_TriggerPriceTypeScope_allocate);
  rb_define_method(cTriggerPriceTypeScope.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPriceTypeScope), -1);
  cTriggerPriceTypeScope.mark = 0;
  cTriggerPriceTypeScope.destroy = (void (*)(void *)) free_FIX_TriggerPriceTypeScope;
  cTriggerPriceTypeScope.trackObjects = 0;
  
  cLastNetworkResponseID.klass = rb_define_class_under(mQuickfix, "LastNetworkResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastNetworkResponseID, (void *) &cLastNetworkResponseID);
  rb_define_alloc_func(cLastNetworkResponseID.klass, _wrap_LastNetworkResponseID_allocate);
  rb_define_method(cLastNetworkResponseID.klass, "initialize", VALUEFUNC(_wrap_new_LastNetworkResponseID), -1);
  cLastNetworkResponseID.mark = 0;
  cLastNetworkResponseID.destroy = (void (*)(void *)) free_FIX_LastNetworkResponseID;
  cLastNetworkResponseID.trackObjects = 0;
  
  cUnderlyingSettlPriceType.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlPriceType, (void *) &cUnderlyingSettlPriceType);
  rb_define_alloc_func(cUnderlyingSettlPriceType.klass, _wrap_UnderlyingSettlPriceType_allocate);
  rb_define_method(cUnderlyingSettlPriceType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlPriceType), -1);
  cUnderlyingSettlPriceType.mark = 0;
  cUnderlyingSettlPriceType.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlPriceType;
  cUnderlyingSettlPriceType.trackObjects = 0;
  
  cApplReportID.klass = rb_define_class_under(mQuickfix, "ApplReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReportID, (void *) &cApplReportID);
  rb_define_alloc_func(cApplReportID.klass, _wrap_ApplReportID_allocate);
  rb_define_method(cApplReportID.klass, "initialize", VALUEFUNC(_wrap_new_ApplReportID), -1);
  cApplReportID.mark = 0;
  cApplReportID.destroy = (void (*)(void *)) free_FIX_ApplReportID;
  cApplReportID.trackObjects = 0;
  
  cPegLimitType.klass = rb_define_class_under(mQuickfix, "PegLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegLimitType, (void *) &cPegLimitType);
  rb_define_alloc_func(cPegLimitType.klass, _wrap_PegLimitType_allocate);
  rb_define_method(cPegLimitType.klass, "initialize", VALUEFUNC(_wrap_new_PegLimitType), -1);
  cPegLimitType.mark = 0;
  cPegLimitType.destroy = (void (*)(void *)) free_FIX_PegLimitType;
  cPegLimitType.trackObjects = 0;
  
  cExecID.klass = rb_define_class_under(mQuickfix, "ExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecID, (void *) &cExecID);
  rb_define_alloc_func(cExecID.klass, _wrap_ExecID_allocate);
  rb_define_method(cExecID.klass, "initialize", VALUEFUNC(_wrap_new_ExecID), -1);
  cExecID.mark = 0;
  cExecID.destroy = (void (*)(void *)) free_FIX_ExecID;
  cExecID.trackObjects = 0;
  
  cSide.klass = rb_define_class_under(mQuickfix, "Side", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Side, (void *) &cSide);
  rb_define_alloc_func(cSide.klass, _wrap_Side_allocate);
  rb_define_method(cSide.klass, "initialize", VALUEFUNC(_wrap_new_Side), -1);
  cSide.mark = 0;
  cSide.destroy = (void (*)(void *)) free_FIX_Side;
  cSide.trackObjects = 0;
  
  cUnderlyingLastPx.klass = rb_define_class_under(mQuickfix, "UnderlyingLastPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLastPx, (void *) &cUnderlyingLastPx);
  rb_define_alloc_func(cUnderlyingLastPx.klass, _wrap_UnderlyingLastPx_allocate);
  rb_define_method(cUnderlyingLastPx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLastPx), -1);
  cUnderlyingLastPx.mark = 0;
  cUnderlyingLastPx.destroy = (void (*)(void *)) free_FIX_UnderlyingLastPx;
  cUnderlyingLastPx.trackObjects = 0;
  
  cMarketDepth.klass = rb_define_class_under(mQuickfix, "MarketDepth", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketDepth, (void *) &cMarketDepth);
  rb_define_alloc_func(cMarketDepth.klass, _wrap_MarketDepth_allocate);
  rb_define_method(cMarketDepth.klass, "initialize", VALUEFUNC(_wrap_new_MarketDepth), -1);
  cMarketDepth.mark = 0;
  cMarketDepth.destroy = (void (*)(void *)) free_FIX_MarketDepth;
  cMarketDepth.trackObjects = 0;
  
  cDiscretionOffset.klass = rb_define_class_under(mQuickfix, "DiscretionOffset", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionOffset, (void *) &cDiscretionOffset);
  rb_define_alloc_func(cDiscretionOffset.klass, _wrap_DiscretionOffset_allocate);
  rb_define_method(cDiscretionOffset.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionOffset), -1);
  cDiscretionOffset.mark = 0;
  cDiscretionOffset.destroy = (void (*)(void *)) free_FIX_DiscretionOffset;
  cDiscretionOffset.trackObjects = 0;
  
  cContAmtType.klass = rb_define_class_under(mQuickfix, "ContAmtType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContAmtType, (void *) &cContAmtType);
  rb_define_alloc_func(cContAmtType.klass, _wrap_ContAmtType_allocate);
  rb_define_method(cContAmtType.klass, "initialize", VALUEFUNC(_wrap_new_ContAmtType), -1);
  cContAmtType.mark = 0;
  cContAmtType.destroy = (void (*)(void *)) free_FIX_ContAmtType;
  cContAmtType.trackObjects = 0;
  
  cMiscFeeCurr.klass = rb_define_class_under(mQuickfix, "MiscFeeCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeCurr, (void *) &cMiscFeeCurr);
  rb_define_alloc_func(cMiscFeeCurr.klass, _wrap_MiscFeeCurr_allocate);
  rb_define_method(cMiscFeeCurr.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeCurr), -1);
  cMiscFeeCurr.mark = 0;
  cMiscFeeCurr.destroy = (void (*)(void *)) free_FIX_MiscFeeCurr;
  cMiscFeeCurr.trackObjects = 0;
  
  cNoRiskLimits.klass = rb_define_class_under(mQuickfix, "NoRiskLimits", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRiskLimits, (void *) &cNoRiskLimits);
  rb_define_alloc_func(cNoRiskLimits.klass, _wrap_NoRiskLimits_allocate);
  rb_define_method(cNoRiskLimits.klass, "initialize", VALUEFUNC(_wrap_new_NoRiskLimits), -1);
  cNoRiskLimits.mark = 0;
  cNoRiskLimits.destroy = (void (*)(void *)) free_FIX_NoRiskLimits;
  cNoRiskLimits.trackObjects = 0;
  
  cAttachmentPoint.klass = rb_define_class_under(mQuickfix, "AttachmentPoint", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AttachmentPoint, (void *) &cAttachmentPoint);
  rb_define_alloc_func(cAttachmentPoint.klass, _wrap_AttachmentPoint_allocate);
  rb_define_method(cAttachmentPoint.klass, "initialize", VALUEFUNC(_wrap_new_AttachmentPoint), -1);
  cAttachmentPoint.mark = 0;
  cAttachmentPoint.destroy = (void (*)(void *)) free_FIX_AttachmentPoint;
  cAttachmentPoint.trackObjects = 0;
  
  cOrderCategory.klass = rb_define_class_under(mQuickfix, "OrderCategory", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderCategory, (void *) &cOrderCategory);
  rb_define_alloc_func(cOrderCategory.klass, _wrap_OrderCategory_allocate);
  rb_define_method(cOrderCategory.klass, "initialize", VALUEFUNC(_wrap_new_OrderCategory), -1);
  cOrderCategory.mark = 0;
  cOrderCategory.destroy = (void (*)(void *)) free_FIX_OrderCategory;
  cOrderCategory.trackObjects = 0;
  
  cAdvTransType.klass = rb_define_class_under(mQuickfix, "AdvTransType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvTransType, (void *) &cAdvTransType);
  rb_define_alloc_func(cAdvTransType.klass, _wrap_AdvTransType_allocate);
  rb_define_method(cAdvTransType.klass, "initialize", VALUEFUNC(_wrap_new_AdvTransType), -1);
  cAdvTransType.mark = 0;
  cAdvTransType.destroy = (void (*)(void *)) free_FIX_AdvTransType;
  cAdvTransType.trackObjects = 0;
  
  cWtAverageLiquidity.klass = rb_define_class_under(mQuickfix, "WtAverageLiquidity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__WtAverageLiquidity, (void *) &cWtAverageLiquidity);
  rb_define_alloc_func(cWtAverageLiquidity.klass, _wrap_WtAverageLiquidity_allocate);
  rb_define_method(cWtAverageLiquidity.klass, "initialize", VALUEFUNC(_wrap_new_WtAverageLiquidity), -1);
  cWtAverageLiquidity.mark = 0;
  cWtAverageLiquidity.destroy = (void (*)(void *)) free_FIX_WtAverageLiquidity;
  cWtAverageLiquidity.trackObjects = 0;
  
  cQuoteSetValidUntilTime.klass = rb_define_class_under(mQuickfix, "QuoteSetValidUntilTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteSetValidUntilTime, (void *) &cQuoteSetValidUntilTime);
  rb_define_alloc_func(cQuoteSetValidUntilTime.klass, _wrap_QuoteSetValidUntilTime_allocate);
  rb_define_method(cQuoteSetValidUntilTime.klass, "initialize", VALUEFUNC(_wrap_new_QuoteSetValidUntilTime), -1);
  cQuoteSetValidUntilTime.mark = 0;
  cQuoteSetValidUntilTime.destroy = (void (*)(void *)) free_FIX_QuoteSetValidUntilTime;
  cQuoteSetValidUntilTime.trackObjects = 0;
  
  cNoNested4PartyIDs.klass = rb_define_class_under(mQuickfix, "NoNested4PartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested4PartyIDs, (void *) &cNoNested4PartyIDs);
  rb_define_alloc_func(cNoNested4PartyIDs.klass, _wrap_NoNested4PartyIDs_allocate);
  rb_define_method(cNoNested4PartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested4PartyIDs), -1);
  cNoNested4PartyIDs.mark = 0;
  cNoNested4PartyIDs.destroy = (void (*)(void *)) free_FIX_NoNested4PartyIDs;
  cNoNested4PartyIDs.trackObjects = 0;
  
  cLegPutOrCall.klass = rb_define_class_under(mQuickfix, "LegPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPutOrCall, (void *) &cLegPutOrCall);
  rb_define_alloc_func(cLegPutOrCall.klass, _wrap_LegPutOrCall_allocate);
  rb_define_method(cLegPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_LegPutOrCall), -1);
  cLegPutOrCall.mark = 0;
  cLegPutOrCall.destroy = (void (*)(void *)) free_FIX_LegPutOrCall;
  cLegPutOrCall.trackObjects = 0;
  
  cUserStatusText.klass = rb_define_class_under(mQuickfix, "UserStatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserStatusText, (void *) &cUserStatusText);
  rb_define_alloc_func(cUserStatusText.klass, _wrap_UserStatusText_allocate);
  rb_define_method(cUserStatusText.klass, "initialize", VALUEFUNC(_wrap_new_UserStatusText), -1);
  cUserStatusText.mark = 0;
  cUserStatusText.destroy = (void (*)(void *)) free_FIX_UserStatusText;
  cUserStatusText.trackObjects = 0;
  
  cNested2PartySubID.klass = rb_define_class_under(mQuickfix, "Nested2PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartySubID, (void *) &cNested2PartySubID);
  rb_define_alloc_func(cNested2PartySubID.klass, _wrap_Nested2PartySubID_allocate);
  rb_define_method(cNested2PartySubID.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartySubID), -1);
  cNested2PartySubID.mark = 0;
  cNested2PartySubID.destroy = (void (*)(void *)) free_FIX_Nested2PartySubID;
  cNested2PartySubID.trackObjects = 0;
  
  cEFPTrackingError.klass = rb_define_class_under(mQuickfix, "EFPTrackingError", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EFPTrackingError, (void *) &cEFPTrackingError);
  rb_define_alloc_func(cEFPTrackingError.klass, _wrap_EFPTrackingError_allocate);
  rb_define_method(cEFPTrackingError.klass, "initialize", VALUEFUNC(_wrap_new_EFPTrackingError), -1);
  cEFPTrackingError.mark = 0;
  cEFPTrackingError.destroy = (void (*)(void *)) free_FIX_EFPTrackingError;
  cEFPTrackingError.trackObjects = 0;
  
  cSideLiquidityInd.klass = rb_define_class_under(mQuickfix, "SideLiquidityInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideLiquidityInd, (void *) &cSideLiquidityInd);
  rb_define_alloc_func(cSideLiquidityInd.klass, _wrap_SideLiquidityInd_allocate);
  rb_define_method(cSideLiquidityInd.klass, "initialize", VALUEFUNC(_wrap_new_SideLiquidityInd), -1);
  cSideLiquidityInd.mark = 0;
  cSideLiquidityInd.destroy = (void (*)(void *)) free_FIX_SideLiquidityInd;
  cSideLiquidityInd.trackObjects = 0;
  
  cDerivativeMinPriceIncrement.klass = rb_define_class_under(mQuickfix, "DerivativeMinPriceIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMinPriceIncrement, (void *) &cDerivativeMinPriceIncrement);
  rb_define_alloc_func(cDerivativeMinPriceIncrement.klass, _wrap_DerivativeMinPriceIncrement_allocate);
  rb_define_method(cDerivativeMinPriceIncrement.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMinPriceIncrement), -1);
  cDerivativeMinPriceIncrement.mark = 0;
  cDerivativeMinPriceIncrement.destroy = (void (*)(void *)) free_FIX_DerivativeMinPriceIncrement;
  cDerivativeMinPriceIncrement.trackObjects = 0;
  
  cPublishTrdIndicator.klass = rb_define_class_under(mQuickfix, "PublishTrdIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PublishTrdIndicator, (void *) &cPublishTrdIndicator);
  rb_define_alloc_func(cPublishTrdIndicator.klass, _wrap_PublishTrdIndicator_allocate);
  rb_define_method(cPublishTrdIndicator.klass, "initialize", VALUEFUNC(_wrap_new_PublishTrdIndicator), -1);
  cPublishTrdIndicator.mark = 0;
  cPublishTrdIndicator.destroy = (void (*)(void *)) free_FIX_PublishTrdIndicator;
  cPublishTrdIndicator.trackObjects = 0;
  
  cInvestorCountryOfResidence.klass = rb_define_class_under(mQuickfix, "InvestorCountryOfResidence", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InvestorCountryOfResidence, (void *) &cInvestorCountryOfResidence);
  rb_define_alloc_func(cInvestorCountryOfResidence.klass, _wrap_InvestorCountryOfResidence_allocate);
  rb_define_method(cInvestorCountryOfResidence.klass, "initialize", VALUEFUNC(_wrap_new_InvestorCountryOfResidence), -1);
  cInvestorCountryOfResidence.mark = 0;
  cInvestorCountryOfResidence.destroy = (void (*)(void *)) free_FIX_InvestorCountryOfResidence;
  cInvestorCountryOfResidence.trackObjects = 0;
  
  cSideReasonCd.klass = rb_define_class_under(mQuickfix, "SideReasonCd", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideReasonCd, (void *) &cSideReasonCd);
  rb_define_alloc_func(cSideReasonCd.klass, _wrap_SideReasonCd_allocate);
  rb_define_method(cSideReasonCd.klass, "initialize", VALUEFUNC(_wrap_new_SideReasonCd), -1);
  cSideReasonCd.mark = 0;
  cSideReasonCd.destroy = (void (*)(void *)) free_FIX_SideReasonCd;
  cSideReasonCd.trackObjects = 0;
  
  cMinPriceIncrement.klass = rb_define_class_under(mQuickfix, "MinPriceIncrement", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinPriceIncrement, (void *) &cMinPriceIncrement);
  rb_define_alloc_func(cMinPriceIncrement.klass, _wrap_MinPriceIncrement_allocate);
  rb_define_method(cMinPriceIncrement.klass, "initialize", VALUEFUNC(_wrap_new_MinPriceIncrement), -1);
  cMinPriceIncrement.mark = 0;
  cMinPriceIncrement.destroy = (void (*)(void *)) free_FIX_MinPriceIncrement;
  cMinPriceIncrement.trackObjects = 0;
  
  cSecuritySettlAgentContactName.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentContactName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentContactName, (void *) &cSecuritySettlAgentContactName);
  rb_define_alloc_func(cSecuritySettlAgentContactName.klass, _wrap_SecuritySettlAgentContactName_allocate);
  rb_define_method(cSecuritySettlAgentContactName.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentContactName), -1);
  cSecuritySettlAgentContactName.mark = 0;
  cSecuritySettlAgentContactName.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentContactName;
  cSecuritySettlAgentContactName.trackObjects = 0;
  
  cSecurityResponseType.klass = rb_define_class_under(mQuickfix, "SecurityResponseType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityResponseType, (void *) &cSecurityResponseType);
  rb_define_alloc_func(cSecurityResponseType.klass, _wrap_SecurityResponseType_allocate);
  rb_define_method(cSecurityResponseType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityResponseType), -1);
  cSecurityResponseType.mark = 0;
  cSecurityResponseType.destroy = (void (*)(void *)) free_FIX_SecurityResponseType;
  cSecurityResponseType.trackObjects = 0;
  
  cLegBenchmarkCurvePoint.klass = rb_define_class_under(mQuickfix, "LegBenchmarkCurvePoint", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkCurvePoint, (void *) &cLegBenchmarkCurvePoint);
  rb_define_alloc_func(cLegBenchmarkCurvePoint.klass, _wrap_LegBenchmarkCurvePoint_allocate);
  rb_define_method(cLegBenchmarkCurvePoint.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkCurvePoint), -1);
  cLegBenchmarkCurvePoint.mark = 0;
  cLegBenchmarkCurvePoint.destroy = (void (*)(void *)) free_FIX_LegBenchmarkCurvePoint;
  cLegBenchmarkCurvePoint.trackObjects = 0;
  
  cClearingFirm.klass = rb_define_class_under(mQuickfix, "ClearingFirm", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingFirm, (void *) &cClearingFirm);
  rb_define_alloc_func(cClearingFirm.klass, _wrap_ClearingFirm_allocate);
  rb_define_method(cClearingFirm.klass, "initialize", VALUEFUNC(_wrap_new_ClearingFirm), -1);
  cClearingFirm.mark = 0;
  cClearingFirm.destroy = (void (*)(void *)) free_FIX_ClearingFirm;
  cClearingFirm.trackObjects = 0;
  
  cRelationshipRiskSecurityIDSource.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityIDSource, (void *) &cRelationshipRiskSecurityIDSource);
  rb_define_alloc_func(cRelationshipRiskSecurityIDSource.klass, _wrap_RelationshipRiskSecurityIDSource_allocate);
  rb_define_method(cRelationshipRiskSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityIDSource), -1);
  cRelationshipRiskSecurityIDSource.mark = 0;
  cRelationshipRiskSecurityIDSource.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityIDSource;
  cRelationshipRiskSecurityIDSource.trackObjects = 0;
  
  cSessionStatus.klass = rb_define_class_under(mQuickfix, "SessionStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionStatus, (void *) &cSessionStatus);
  rb_define_alloc_func(cSessionStatus.klass, _wrap_SessionStatus_allocate);
  rb_define_method(cSessionStatus.klass, "initialize", VALUEFUNC(_wrap_new_SessionStatus), -1);
  cSessionStatus.mark = 0;
  cSessionStatus.destroy = (void (*)(void *)) free_FIX_SessionStatus;
  cSessionStatus.trackObjects = 0;
  
  cTriggerSecurityID.klass = rb_define_class_under(mQuickfix, "TriggerSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSecurityID, (void *) &cTriggerSecurityID);
  rb_define_alloc_func(cTriggerSecurityID.klass, _wrap_TriggerSecurityID_allocate);
  rb_define_method(cTriggerSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSecurityID), -1);
  cTriggerSecurityID.mark = 0;
  cTriggerSecurityID.destroy = (void (*)(void *)) free_FIX_TriggerSecurityID;
  cTriggerSecurityID.trackObjects = 0;
  
  cTotNoAllocs.klass = rb_define_class_under(mQuickfix, "TotNoAllocs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoAllocs, (void *) &cTotNoAllocs);
  rb_define_alloc_func(cTotNoAllocs.klass, _wrap_TotNoAllocs_allocate);
  rb_define_method(cTotNoAllocs.klass, "initialize", VALUEFUNC(_wrap_new_TotNoAllocs), -1);
  cTotNoAllocs.mark = 0;
  cTotNoAllocs.destroy = (void (*)(void *)) free_FIX_TotNoAllocs;
  cTotNoAllocs.trackObjects = 0;
  
  cNoAltMDSource.klass = rb_define_class_under(mQuickfix, "NoAltMDSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAltMDSource, (void *) &cNoAltMDSource);
  rb_define_alloc_func(cNoAltMDSource.klass, _wrap_NoAltMDSource_allocate);
  rb_define_method(cNoAltMDSource.klass, "initialize", VALUEFUNC(_wrap_new_NoAltMDSource), -1);
  cNoAltMDSource.mark = 0;
  cNoAltMDSource.destroy = (void (*)(void *)) free_FIX_NoAltMDSource;
  cNoAltMDSource.trackObjects = 0;
  
  cAllocAccountType.klass = rb_define_class_under(mQuickfix, "AllocAccountType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAccountType, (void *) &cAllocAccountType);
  rb_define_alloc_func(cAllocAccountType.klass, _wrap_AllocAccountType_allocate);
  rb_define_method(cAllocAccountType.klass, "initialize", VALUEFUNC(_wrap_new_AllocAccountType), -1);
  cAllocAccountType.mark = 0;
  cAllocAccountType.destroy = (void (*)(void *)) free_FIX_AllocAccountType;
  cAllocAccountType.trackObjects = 0;
  
  cLastPx.klass = rb_define_class_under(mQuickfix, "LastPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastPx, (void *) &cLastPx);
  rb_define_alloc_func(cLastPx.klass, _wrap_LastPx_allocate);
  rb_define_method(cLastPx.klass, "initialize", VALUEFUNC(_wrap_new_LastPx), -1);
  cLastPx.mark = 0;
  cLastPx.destroy = (void (*)(void *)) free_FIX_LastPx;
  cLastPx.trackObjects = 0;
  
  cAllocTransType.klass = rb_define_class_under(mQuickfix, "AllocTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocTransType, (void *) &cAllocTransType);
  rb_define_alloc_func(cAllocTransType.klass, _wrap_AllocTransType_allocate);
  rb_define_method(cAllocTransType.klass, "initialize", VALUEFUNC(_wrap_new_AllocTransType), -1);
  cAllocTransType.mark = 0;
  cAllocTransType.destroy = (void (*)(void *)) free_FIX_AllocTransType;
  cAllocTransType.trackObjects = 0;
  
  cTotNoQuoteEntries.klass = rb_define_class_under(mQuickfix, "TotNoQuoteEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoQuoteEntries, (void *) &cTotNoQuoteEntries);
  rb_define_alloc_func(cTotNoQuoteEntries.klass, _wrap_TotNoQuoteEntries_allocate);
  rb_define_method(cTotNoQuoteEntries.klass, "initialize", VALUEFUNC(_wrap_new_TotNoQuoteEntries), -1);
  cTotNoQuoteEntries.mark = 0;
  cTotNoQuoteEntries.destroy = (void (*)(void *)) free_FIX_TotNoQuoteEntries;
  cTotNoQuoteEntries.trackObjects = 0;
  
  cMinBidSize.klass = rb_define_class_under(mQuickfix, "MinBidSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinBidSize, (void *) &cMinBidSize);
  rb_define_alloc_func(cMinBidSize.klass, _wrap_MinBidSize_allocate);
  rb_define_method(cMinBidSize.klass, "initialize", VALUEFUNC(_wrap_new_MinBidSize), -1);
  cMinBidSize.mark = 0;
  cMinBidSize.destroy = (void (*)(void *)) free_FIX_MinBidSize;
  cMinBidSize.trackObjects = 0;
  
  cSettlBrkrCode.klass = rb_define_class_under(mQuickfix, "SettlBrkrCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlBrkrCode, (void *) &cSettlBrkrCode);
  rb_define_alloc_func(cSettlBrkrCode.klass, _wrap_SettlBrkrCode_allocate);
  rb_define_method(cSettlBrkrCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlBrkrCode), -1);
  cSettlBrkrCode.mark = 0;
  cSettlBrkrCode.destroy = (void (*)(void *)) free_FIX_SettlBrkrCode;
  cSettlBrkrCode.trackObjects = 0;
  
  cCardHolderName.klass = rb_define_class_under(mQuickfix, "CardHolderName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardHolderName, (void *) &cCardHolderName);
  rb_define_alloc_func(cCardHolderName.klass, _wrap_CardHolderName_allocate);
  rb_define_method(cCardHolderName.klass, "initialize", VALUEFUNC(_wrap_new_CardHolderName), -1);
  cCardHolderName.mark = 0;
  cCardHolderName.destroy = (void (*)(void *)) free_FIX_CardHolderName;
  cCardHolderName.trackObjects = 0;
  
  cExpirationQtyType.klass = rb_define_class_under(mQuickfix, "ExpirationQtyType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpirationQtyType, (void *) &cExpirationQtyType);
  rb_define_alloc_func(cExpirationQtyType.klass, _wrap_ExpirationQtyType_allocate);
  rb_define_method(cExpirationQtyType.klass, "initialize", VALUEFUNC(_wrap_new_ExpirationQtyType), -1);
  cExpirationQtyType.mark = 0;
  cExpirationQtyType.destroy = (void (*)(void *)) free_FIX_ExpirationQtyType;
  cExpirationQtyType.trackObjects = 0;
  
  cEncodedUnderlyingSecurityDescLen.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen, (void *) &cEncodedUnderlyingSecurityDescLen);
  rb_define_alloc_func(cEncodedUnderlyingSecurityDescLen.klass, _wrap_EncodedUnderlyingSecurityDescLen_allocate);
  rb_define_method(cEncodedUnderlyingSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingSecurityDescLen), -1);
  cEncodedUnderlyingSecurityDescLen.mark = 0;
  cEncodedUnderlyingSecurityDescLen.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingSecurityDescLen;
  cEncodedUnderlyingSecurityDescLen.trackObjects = 0;
  
  cQuoteReqID.klass = rb_define_class_under(mQuickfix, "QuoteReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteReqID, (void *) &cQuoteReqID);
  rb_define_alloc_func(cQuoteReqID.klass, _wrap_QuoteReqID_allocate);
  rb_define_method(cQuoteReqID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteReqID), -1);
  cQuoteReqID.mark = 0;
  cQuoteReqID.destroy = (void (*)(void *)) free_FIX_QuoteReqID;
  cQuoteReqID.trackObjects = 0;
  
  cNoRelatedPartyAltSubIDs.klass = rb_define_class_under(mQuickfix, "NoRelatedPartyAltSubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedPartyAltSubIDs, (void *) &cNoRelatedPartyAltSubIDs);
  rb_define_alloc_func(cNoRelatedPartyAltSubIDs.klass, _wrap_NoRelatedPartyAltSubIDs_allocate);
  rb_define_method(cNoRelatedPartyAltSubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedPartyAltSubIDs), -1);
  cNoRelatedPartyAltSubIDs.mark = 0;
  cNoRelatedPartyAltSubIDs.destroy = (void (*)(void *)) free_FIX_NoRelatedPartyAltSubIDs;
  cNoRelatedPartyAltSubIDs.trackObjects = 0;
  
  cRiskProduct.klass = rb_define_class_under(mQuickfix, "RiskProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskProduct, (void *) &cRiskProduct);
  rb_define_alloc_func(cRiskProduct.klass, _wrap_RiskProduct_allocate);
  rb_define_method(cRiskProduct.klass, "initialize", VALUEFUNC(_wrap_new_RiskProduct), -1);
  cRiskProduct.mark = 0;
  cRiskProduct.destroy = (void (*)(void *)) free_FIX_RiskProduct;
  cRiskProduct.trackObjects = 0;
  
  cRiskSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "RiskSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityAltIDSource, (void *) &cRiskSecurityAltIDSource);
  rb_define_alloc_func(cRiskSecurityAltIDSource.klass, _wrap_RiskSecurityAltIDSource_allocate);
  rb_define_method(cRiskSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityAltIDSource), -1);
  cRiskSecurityAltIDSource.mark = 0;
  cRiskSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_RiskSecurityAltIDSource;
  cRiskSecurityAltIDSource.trackObjects = 0;
  
  cPriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "PriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceUnitOfMeasure, (void *) &cPriceUnitOfMeasure);
  rb_define_alloc_func(cPriceUnitOfMeasure.klass, _wrap_PriceUnitOfMeasure_allocate);
  rb_define_method(cPriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_PriceUnitOfMeasure), -1);
  cPriceUnitOfMeasure.mark = 0;
  cPriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_PriceUnitOfMeasure;
  cPriceUnitOfMeasure.trackObjects = 0;
  
  cTZTransactTime.klass = rb_define_class_under(mQuickfix, "TZTransactTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TZTransactTime, (void *) &cTZTransactTime);
  rb_define_alloc_func(cTZTransactTime.klass, _wrap_TZTransactTime_allocate);
  rb_define_method(cTZTransactTime.klass, "initialize", VALUEFUNC(_wrap_new_TZTransactTime), -1);
  cTZTransactTime.mark = 0;
  cTZTransactTime.destroy = (void (*)(void *)) free_FIX_TZTransactTime;
  cTZTransactTime.trackObjects = 0;
  
  cAllocHandlInst.klass = rb_define_class_under(mQuickfix, "AllocHandlInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocHandlInst, (void *) &cAllocHandlInst);
  rb_define_alloc_func(cAllocHandlInst.klass, _wrap_AllocHandlInst_allocate);
  rb_define_method(cAllocHandlInst.klass, "initialize", VALUEFUNC(_wrap_new_AllocHandlInst), -1);
  cAllocHandlInst.mark = 0;
  cAllocHandlInst.destroy = (void (*)(void *)) free_FIX_AllocHandlInst;
  cAllocHandlInst.trackObjects = 0;
  
  cUnderlyingInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource, (void *) &cUnderlyingInstrumentPartyIDSource);
  rb_define_alloc_func(cUnderlyingInstrumentPartyIDSource.klass, _wrap_UnderlyingInstrumentPartyIDSource_allocate);
  rb_define_method(cUnderlyingInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartyIDSource), -1);
  cUnderlyingInstrumentPartyIDSource.mark = 0;
  cUnderlyingInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartyIDSource;
  cUnderlyingInstrumentPartyIDSource.trackObjects = 0;
  
  cCurrencyRatio.klass = rb_define_class_under(mQuickfix, "CurrencyRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CurrencyRatio, (void *) &cCurrencyRatio);
  rb_define_alloc_func(cCurrencyRatio.klass, _wrap_CurrencyRatio_allocate);
  rb_define_method(cCurrencyRatio.klass, "initialize", VALUEFUNC(_wrap_new_CurrencyRatio), -1);
  cCurrencyRatio.mark = 0;
  cCurrencyRatio.destroy = (void (*)(void *)) free_FIX_CurrencyRatio;
  cCurrencyRatio.trackObjects = 0;
  
  cRefreshQty.klass = rb_define_class_under(mQuickfix, "RefreshQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefreshQty, (void *) &cRefreshQty);
  rb_define_alloc_func(cRefreshQty.klass, _wrap_RefreshQty_allocate);
  rb_define_method(cRefreshQty.klass, "initialize", VALUEFUNC(_wrap_new_RefreshQty), -1);
  cRefreshQty.mark = 0;
  cRefreshQty.destroy = (void (*)(void *)) free_FIX_RefreshQty;
  cRefreshQty.trackObjects = 0;
  
  cTradeRequestStatus.klass = rb_define_class_under(mQuickfix, "TradeRequestStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeRequestStatus, (void *) &cTradeRequestStatus);
  rb_define_alloc_func(cTradeRequestStatus.klass, _wrap_TradeRequestStatus_allocate);
  rb_define_method(cTradeRequestStatus.klass, "initialize", VALUEFUNC(_wrap_new_TradeRequestStatus), -1);
  cTradeRequestStatus.mark = 0;
  cTradeRequestStatus.destroy = (void (*)(void *)) free_FIX_TradeRequestStatus;
  cTradeRequestStatus.trackObjects = 0;
  
  cTrdRepIndicator.klass = rb_define_class_under(mQuickfix, "TrdRepIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRepIndicator, (void *) &cTrdRepIndicator);
  rb_define_alloc_func(cTrdRepIndicator.klass, _wrap_TrdRepIndicator_allocate);
  rb_define_method(cTrdRepIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TrdRepIndicator), -1);
  cTrdRepIndicator.mark = 0;
  cTrdRepIndicator.destroy = (void (*)(void *)) free_FIX_TrdRepIndicator;
  cTrdRepIndicator.trackObjects = 0;
  
  cMiscFeeAmt.klass = rb_define_class_under(mQuickfix, "MiscFeeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeAmt, (void *) &cMiscFeeAmt);
  rb_define_alloc_func(cMiscFeeAmt.klass, _wrap_MiscFeeAmt_allocate);
  rb_define_method(cMiscFeeAmt.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeAmt), -1);
  cMiscFeeAmt.mark = 0;
  cMiscFeeAmt.destroy = (void (*)(void *)) free_FIX_MiscFeeAmt;
  cMiscFeeAmt.trackObjects = 0;
  
  cTradSesOpenTime.klass = rb_define_class_under(mQuickfix, "TradSesOpenTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesOpenTime, (void *) &cTradSesOpenTime);
  rb_define_alloc_func(cTradSesOpenTime.klass, _wrap_TradSesOpenTime_allocate);
  rb_define_method(cTradSesOpenTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesOpenTime), -1);
  cTradSesOpenTime.mark = 0;
  cTradSesOpenTime.destroy = (void (*)(void *)) free_FIX_TradSesOpenTime;
  cTradSesOpenTime.trackObjects = 0;
  
  cPreallocMethod.klass = rb_define_class_under(mQuickfix, "PreallocMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PreallocMethod, (void *) &cPreallocMethod);
  rb_define_alloc_func(cPreallocMethod.klass, _wrap_PreallocMethod_allocate);
  rb_define_method(cPreallocMethod.klass, "initialize", VALUEFUNC(_wrap_new_PreallocMethod), -1);
  cPreallocMethod.mark = 0;
  cPreallocMethod.destroy = (void (*)(void *)) free_FIX_PreallocMethod;
  cPreallocMethod.trackObjects = 0;
  
  cTaxAdvantageType.klass = rb_define_class_under(mQuickfix, "TaxAdvantageType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TaxAdvantageType, (void *) &cTaxAdvantageType);
  rb_define_alloc_func(cTaxAdvantageType.klass, _wrap_TaxAdvantageType_allocate);
  rb_define_method(cTaxAdvantageType.klass, "initialize", VALUEFUNC(_wrap_new_TaxAdvantageType), -1);
  cTaxAdvantageType.mark = 0;
  cTaxAdvantageType.destroy = (void (*)(void *)) free_FIX_TaxAdvantageType;
  cTaxAdvantageType.trackObjects = 0;
  
  cMessageEncoding.klass = rb_define_class_under(mQuickfix, "MessageEncoding", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageEncoding, (void *) &cMessageEncoding);
  rb_define_alloc_func(cMessageEncoding.klass, _wrap_MessageEncoding_allocate);
  rb_define_method(cMessageEncoding.klass, "initialize", VALUEFUNC(_wrap_new_MessageEncoding), -1);
  cMessageEncoding.mark = 0;
  cMessageEncoding.destroy = (void (*)(void *)) free_FIX_MessageEncoding;
  cMessageEncoding.trackObjects = 0;
  
  cRiskPutOrCall.klass = rb_define_class_under(mQuickfix, "RiskPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskPutOrCall, (void *) &cRiskPutOrCall);
  rb_define_alloc_func(cRiskPutOrCall.klass, _wrap_RiskPutOrCall_allocate);
  rb_define_method(cRiskPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_RiskPutOrCall), -1);
  cRiskPutOrCall.mark = 0;
  cRiskPutOrCall.destroy = (void (*)(void *)) free_FIX_RiskPutOrCall;
  cRiskPutOrCall.trackObjects = 0;
  
  cRiskSecurityGroup.klass = rb_define_class_under(mQuickfix, "RiskSecurityGroup", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityGroup, (void *) &cRiskSecurityGroup);
  rb_define_alloc_func(cRiskSecurityGroup.klass, _wrap_RiskSecurityGroup_allocate);
  rb_define_method(cRiskSecurityGroup.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityGroup), -1);
  cRiskSecurityGroup.mark = 0;
  cRiskSecurityGroup.destroy = (void (*)(void *)) free_FIX_RiskSecurityGroup;
  cRiskSecurityGroup.trackObjects = 0;
  
  cNoPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartySubIDs, (void *) &cNoPartySubIDs);
  rb_define_alloc_func(cNoPartySubIDs.klass, _wrap_NoPartySubIDs_allocate);
  rb_define_method(cNoPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoPartySubIDs), -1);
  cNoPartySubIDs.mark = 0;
  cNoPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoPartySubIDs;
  cNoPartySubIDs.trackObjects = 0;
  
  cSettlInstReqID.klass = rb_define_class_under(mQuickfix, "SettlInstReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstReqID, (void *) &cSettlInstReqID);
  rb_define_alloc_func(cSettlInstReqID.klass, _wrap_SettlInstReqID_allocate);
  rb_define_method(cSettlInstReqID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstReqID), -1);
  cSettlInstReqID.mark = 0;
  cSettlInstReqID.destroy = (void (*)(void *)) free_FIX_SettlInstReqID;
  cSettlInstReqID.trackObjects = 0;
  
  cLegRepoCollateralSecurityType.klass = rb_define_class_under(mQuickfix, "LegRepoCollateralSecurityType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRepoCollateralSecurityType, (void *) &cLegRepoCollateralSecurityType);
  rb_define_alloc_func(cLegRepoCollateralSecurityType.klass, _wrap_LegRepoCollateralSecurityType_allocate);
  rb_define_method(cLegRepoCollateralSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_LegRepoCollateralSecurityType), -1);
  cLegRepoCollateralSecurityType.mark = 0;
  cLegRepoCollateralSecurityType.destroy = (void (*)(void *)) free_FIX_LegRepoCollateralSecurityType;
  cLegRepoCollateralSecurityType.trackObjects = 0;
  
  cAffectedSecondaryOrderID.klass = rb_define_class_under(mQuickfix, "AffectedSecondaryOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AffectedSecondaryOrderID, (void *) &cAffectedSecondaryOrderID);
  rb_define_alloc_func(cAffectedSecondaryOrderID.klass, _wrap_AffectedSecondaryOrderID_allocate);
  rb_define_method(cAffectedSecondaryOrderID.klass, "initialize", VALUEFUNC(_wrap_new_AffectedSecondaryOrderID), -1);
  cAffectedSecondaryOrderID.mark = 0;
  cAffectedSecondaryOrderID.destroy = (void (*)(void *)) free_FIX_AffectedSecondaryOrderID;
  cAffectedSecondaryOrderID.trackObjects = 0;
  
  cRiskSymbol.klass = rb_define_class_under(mQuickfix, "RiskSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSymbol, (void *) &cRiskSymbol);
  rb_define_alloc_func(cRiskSymbol.klass, _wrap_RiskSymbol_allocate);
  rb_define_method(cRiskSymbol.klass, "initialize", VALUEFUNC(_wrap_new_RiskSymbol), -1);
  cRiskSymbol.mark = 0;
  cRiskSymbol.destroy = (void (*)(void *)) free_FIX_RiskSymbol;
  cRiskSymbol.trackObjects = 0;
  
  cDerivativeMaturityTime.klass = rb_define_class_under(mQuickfix, "DerivativeMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMaturityTime, (void *) &cDerivativeMaturityTime);
  rb_define_alloc_func(cDerivativeMaturityTime.klass, _wrap_DerivativeMaturityTime_allocate);
  rb_define_method(cDerivativeMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMaturityTime), -1);
  cDerivativeMaturityTime.mark = 0;
  cDerivativeMaturityTime.destroy = (void (*)(void *)) free_FIX_DerivativeMaturityTime;
  cDerivativeMaturityTime.trackObjects = 0;
  
  cExpireTime.klass = rb_define_class_under(mQuickfix, "ExpireTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpireTime, (void *) &cExpireTime);
  rb_define_alloc_func(cExpireTime.klass, _wrap_ExpireTime_allocate);
  rb_define_method(cExpireTime.klass, "initialize", VALUEFUNC(_wrap_new_ExpireTime), -1);
  cExpireTime.mark = 0;
  cExpireTime.destroy = (void (*)(void *)) free_FIX_ExpireTime;
  cExpireTime.trackObjects = 0;
  
  cUnderlyingFactor.klass = rb_define_class_under(mQuickfix, "UnderlyingFactor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFactor, (void *) &cUnderlyingFactor);
  rb_define_alloc_func(cUnderlyingFactor.klass, _wrap_UnderlyingFactor_allocate);
  rb_define_method(cUnderlyingFactor.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFactor), -1);
  cUnderlyingFactor.mark = 0;
  cUnderlyingFactor.destroy = (void (*)(void *)) free_FIX_UnderlyingFactor;
  cUnderlyingFactor.trackObjects = 0;
  
  cOrigOrdModTime.klass = rb_define_class_under(mQuickfix, "OrigOrdModTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigOrdModTime, (void *) &cOrigOrdModTime);
  rb_define_alloc_func(cOrigOrdModTime.klass, _wrap_OrigOrdModTime_allocate);
  rb_define_method(cOrigOrdModTime.klass, "initialize", VALUEFUNC(_wrap_new_OrigOrdModTime), -1);
  cOrigOrdModTime.mark = 0;
  cOrigOrdModTime.destroy = (void (*)(void *)) free_FIX_OrigOrdModTime;
  cOrigOrdModTime.trackObjects = 0;
  
  cNoTrdRepIndicators.klass = rb_define_class_under(mQuickfix, "NoTrdRepIndicators", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTrdRepIndicators, (void *) &cNoTrdRepIndicators);
  rb_define_alloc_func(cNoTrdRepIndicators.klass, _wrap_NoTrdRepIndicators_allocate);
  rb_define_method(cNoTrdRepIndicators.klass, "initialize", VALUEFUNC(_wrap_new_NoTrdRepIndicators), -1);
  cNoTrdRepIndicators.mark = 0;
  cNoTrdRepIndicators.destroy = (void (*)(void *)) free_FIX_NoTrdRepIndicators;
  cNoTrdRepIndicators.trackObjects = 0;
  
  cDerivativeMaturityDate.klass = rb_define_class_under(mQuickfix, "DerivativeMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeMaturityDate, (void *) &cDerivativeMaturityDate);
  rb_define_alloc_func(cDerivativeMaturityDate.klass, _wrap_DerivativeMaturityDate_allocate);
  rb_define_method(cDerivativeMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeMaturityDate), -1);
  cDerivativeMaturityDate.mark = 0;
  cDerivativeMaturityDate.destroy = (void (*)(void *)) free_FIX_DerivativeMaturityDate;
  cDerivativeMaturityDate.trackObjects = 0;
  
  cDerivativeCFICode.klass = rb_define_class_under(mQuickfix, "DerivativeCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeCFICode, (void *) &cDerivativeCFICode);
  rb_define_alloc_func(cDerivativeCFICode.klass, _wrap_DerivativeCFICode_allocate);
  rb_define_method(cDerivativeCFICode.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeCFICode), -1);
  cDerivativeCFICode.mark = 0;
  cDerivativeCFICode.destroy = (void (*)(void *)) free_FIX_DerivativeCFICode;
  cDerivativeCFICode.trackObjects = 0;
  
  cNested2PartySubIDType.klass = rb_define_class_under(mQuickfix, "Nested2PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartySubIDType, (void *) &cNested2PartySubIDType);
  rb_define_alloc_func(cNested2PartySubIDType.klass, _wrap_Nested2PartySubIDType_allocate);
  rb_define_method(cNested2PartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartySubIDType), -1);
  cNested2PartySubIDType.mark = 0;
  cNested2PartySubIDType.destroy = (void (*)(void *)) free_FIX_Nested2PartySubIDType;
  cNested2PartySubIDType.trackObjects = 0;
  
  cLegIOIQty.klass = rb_define_class_under(mQuickfix, "LegIOIQty", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIOIQty, (void *) &cLegIOIQty);
  rb_define_alloc_func(cLegIOIQty.klass, _wrap_LegIOIQty_allocate);
  rb_define_method(cLegIOIQty.klass, "initialize", VALUEFUNC(_wrap_new_LegIOIQty), -1);
  cLegIOIQty.mark = 0;
  cLegIOIQty.destroy = (void (*)(void *)) free_FIX_LegIOIQty;
  cLegIOIQty.trackObjects = 0;
  
  cExpireDate.klass = rb_define_class_under(mQuickfix, "ExpireDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpireDate, (void *) &cExpireDate);
  rb_define_alloc_func(cExpireDate.klass, _wrap_ExpireDate_allocate);
  rb_define_method(cExpireDate.klass, "initialize", VALUEFUNC(_wrap_new_ExpireDate), -1);
  cExpireDate.mark = 0;
  cExpireDate.destroy = (void (*)(void *)) free_FIX_ExpireDate;
  cExpireDate.trackObjects = 0;
  
  cRiskSecurityType.klass = rb_define_class_under(mQuickfix, "RiskSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityType, (void *) &cRiskSecurityType);
  rb_define_alloc_func(cRiskSecurityType.klass, _wrap_RiskSecurityType_allocate);
  rb_define_method(cRiskSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityType), -1);
  cRiskSecurityType.mark = 0;
  cRiskSecurityType.destroy = (void (*)(void *)) free_FIX_RiskSecurityType;
  cRiskSecurityType.trackObjects = 0;
  
  cNoMatchRules.klass = rb_define_class_under(mQuickfix, "NoMatchRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoMatchRules, (void *) &cNoMatchRules);
  rb_define_alloc_func(cNoMatchRules.klass, _wrap_NoMatchRules_allocate);
  rb_define_method(cNoMatchRules.klass, "initialize", VALUEFUNC(_wrap_new_NoMatchRules), -1);
  cNoMatchRules.mark = 0;
  cNoMatchRules.destroy = (void (*)(void *)) free_FIX_NoMatchRules;
  cNoMatchRules.trackObjects = 0;
  
  cApplEndSeqNum.klass = rb_define_class_under(mQuickfix, "ApplEndSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplEndSeqNum, (void *) &cApplEndSeqNum);
  rb_define_alloc_func(cApplEndSeqNum.klass, _wrap_ApplEndSeqNum_allocate);
  rb_define_method(cApplEndSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplEndSeqNum), -1);
  cApplEndSeqNum.mark = 0;
  cApplEndSeqNum.destroy = (void (*)(void *)) free_FIX_ApplEndSeqNum;
  cApplEndSeqNum.trackObjects = 0;
  
  cEventPx.klass = rb_define_class_under(mQuickfix, "EventPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventPx, (void *) &cEventPx);
  rb_define_alloc_func(cEventPx.klass, _wrap_EventPx_allocate);
  rb_define_method(cEventPx.klass, "initialize", VALUEFUNC(_wrap_new_EventPx), -1);
  cEventPx.mark = 0;
  cEventPx.destroy = (void (*)(void *)) free_FIX_EventPx;
  cEventPx.trackObjects = 0;
  
  cAsgnRptID.klass = rb_define_class_under(mQuickfix, "AsgnRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AsgnRptID, (void *) &cAsgnRptID);
  rb_define_alloc_func(cAsgnRptID.klass, _wrap_AsgnRptID_allocate);
  rb_define_method(cAsgnRptID.klass, "initialize", VALUEFUNC(_wrap_new_AsgnRptID), -1);
  cAsgnRptID.mark = 0;
  cAsgnRptID.destroy = (void (*)(void *)) free_FIX_AsgnRptID;
  cAsgnRptID.trackObjects = 0;
  
  cTimeInForce.klass = rb_define_class_under(mQuickfix, "TimeInForce", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeInForce, (void *) &cTimeInForce);
  rb_define_alloc_func(cTimeInForce.klass, _wrap_TimeInForce_allocate);
  rb_define_method(cTimeInForce.klass, "initialize", VALUEFUNC(_wrap_new_TimeInForce), -1);
  cTimeInForce.mark = 0;
  cTimeInForce.destroy = (void (*)(void *)) free_FIX_TimeInForce;
  cTimeInForce.trackObjects = 0;
  
  cLowPx.klass = rb_define_class_under(mQuickfix, "LowPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LowPx, (void *) &cLowPx);
  rb_define_alloc_func(cLowPx.klass, _wrap_LowPx_allocate);
  rb_define_method(cLowPx.klass, "initialize", VALUEFUNC(_wrap_new_LowPx), -1);
  cLowPx.mark = 0;
  cLowPx.destroy = (void (*)(void *)) free_FIX_LowPx;
  cLowPx.trackObjects = 0;
  
  cIOIQualifier.klass = rb_define_class_under(mQuickfix, "IOIQualifier", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIQualifier, (void *) &cIOIQualifier);
  rb_define_alloc_func(cIOIQualifier.klass, _wrap_IOIQualifier_allocate);
  rb_define_method(cIOIQualifier.klass, "initialize", VALUEFUNC(_wrap_new_IOIQualifier), -1);
  cIOIQualifier.mark = 0;
  cIOIQualifier.destroy = (void (*)(void *)) free_FIX_IOIQualifier;
  cIOIQualifier.trackObjects = 0;
  
  cWaveNo.klass = rb_define_class_under(mQuickfix, "WaveNo", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__WaveNo, (void *) &cWaveNo);
  rb_define_alloc_func(cWaveNo.klass, _wrap_WaveNo_allocate);
  rb_define_method(cWaveNo.klass, "initialize", VALUEFUNC(_wrap_new_WaveNo), -1);
  cWaveNo.mark = 0;
  cWaveNo.destroy = (void (*)(void *)) free_FIX_WaveNo;
  cWaveNo.trackObjects = 0;
  
  cRiskSeniority.klass = rb_define_class_under(mQuickfix, "RiskSeniority", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSeniority, (void *) &cRiskSeniority);
  rb_define_alloc_func(cRiskSeniority.klass, _wrap_RiskSeniority_allocate);
  rb_define_method(cRiskSeniority.klass, "initialize", VALUEFUNC(_wrap_new_RiskSeniority), -1);
  cRiskSeniority.mark = 0;
  cRiskSeniority.destroy = (void (*)(void *)) free_FIX_RiskSeniority;
  cRiskSeniority.trackObjects = 0;
  
  cStrikePriceBoundaryMethod.klass = rb_define_class_under(mQuickfix, "StrikePriceBoundaryMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePriceBoundaryMethod, (void *) &cStrikePriceBoundaryMethod);
  rb_define_alloc_func(cStrikePriceBoundaryMethod.klass, _wrap_StrikePriceBoundaryMethod_allocate);
  rb_define_method(cStrikePriceBoundaryMethod.klass, "initialize", VALUEFUNC(_wrap_new_StrikePriceBoundaryMethod), -1);
  cStrikePriceBoundaryMethod.mark = 0;
  cStrikePriceBoundaryMethod.destroy = (void (*)(void *)) free_FIX_StrikePriceBoundaryMethod;
  cStrikePriceBoundaryMethod.trackObjects = 0;
  
  cDerivativeIssueDate.klass = rb_define_class_under(mQuickfix, "DerivativeIssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeIssueDate, (void *) &cDerivativeIssueDate);
  rb_define_alloc_func(cDerivativeIssueDate.klass, _wrap_DerivativeIssueDate_allocate);
  rb_define_method(cDerivativeIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeIssueDate), -1);
  cDerivativeIssueDate.mark = 0;
  cDerivativeIssueDate.destroy = (void (*)(void *)) free_FIX_DerivativeIssueDate;
  cDerivativeIssueDate.trackObjects = 0;
  
  cMiscFeeType.klass = rb_define_class_under(mQuickfix, "MiscFeeType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeType, (void *) &cMiscFeeType);
  rb_define_alloc_func(cMiscFeeType.klass, _wrap_MiscFeeType_allocate);
  rb_define_method(cMiscFeeType.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeType), -1);
  cMiscFeeType.mark = 0;
  cMiscFeeType.destroy = (void (*)(void *)) free_FIX_MiscFeeType;
  cMiscFeeType.trackObjects = 0;
  
  cQuoteID.klass = rb_define_class_under(mQuickfix, "QuoteID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteID, (void *) &cQuoteID);
  rb_define_alloc_func(cQuoteID.klass, _wrap_QuoteID_allocate);
  rb_define_method(cQuoteID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteID), -1);
  cQuoteID.mark = 0;
  cQuoteID.destroy = (void (*)(void *)) free_FIX_QuoteID;
  cQuoteID.trackObjects = 0;
  
  cRiskFlexibleIndicator.klass = rb_define_class_under(mQuickfix, "RiskFlexibleIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskFlexibleIndicator, (void *) &cRiskFlexibleIndicator);
  rb_define_alloc_func(cRiskFlexibleIndicator.klass, _wrap_RiskFlexibleIndicator_allocate);
  rb_define_method(cRiskFlexibleIndicator.klass, "initialize", VALUEFUNC(_wrap_new_RiskFlexibleIndicator), -1);
  cRiskFlexibleIndicator.mark = 0;
  cRiskFlexibleIndicator.destroy = (void (*)(void *)) free_FIX_RiskFlexibleIndicator;
  cRiskFlexibleIndicator.trackObjects = 0;
  
  cDerivativeInstrumentPartyIDSource.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource, (void *) &cDerivativeInstrumentPartyIDSource);
  rb_define_alloc_func(cDerivativeInstrumentPartyIDSource.klass, _wrap_DerivativeInstrumentPartyIDSource_allocate);
  rb_define_method(cDerivativeInstrumentPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartyIDSource), -1);
  cDerivativeInstrumentPartyIDSource.mark = 0;
  cDerivativeInstrumentPartyIDSource.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartyIDSource;
  cDerivativeInstrumentPartyIDSource.trackObjects = 0;
  
  cSettlObligID.klass = rb_define_class_under(mQuickfix, "SettlObligID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligID, (void *) &cSettlObligID);
  rb_define_alloc_func(cSettlObligID.klass, _wrap_SettlObligID_allocate);
  rb_define_method(cSettlObligID.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligID), -1);
  cSettlObligID.mark = 0;
  cSettlObligID.destroy = (void (*)(void *)) free_FIX_SettlObligID;
  cSettlObligID.trackObjects = 0;
  
  cInstrAttribValue.klass = rb_define_class_under(mQuickfix, "InstrAttribValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrAttribValue, (void *) &cInstrAttribValue);
  rb_define_alloc_func(cInstrAttribValue.klass, _wrap_InstrAttribValue_allocate);
  rb_define_method(cInstrAttribValue.klass, "initialize", VALUEFUNC(_wrap_new_InstrAttribValue), -1);
  cInstrAttribValue.mark = 0;
  cInstrAttribValue.destroy = (void (*)(void *)) free_FIX_InstrAttribValue;
  cInstrAttribValue.trackObjects = 0;
  
  cLiquidityValue.klass = rb_define_class_under(mQuickfix, "LiquidityValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityValue, (void *) &cLiquidityValue);
  rb_define_alloc_func(cLiquidityValue.klass, _wrap_LiquidityValue_allocate);
  rb_define_method(cLiquidityValue.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityValue), -1);
  cLiquidityValue.mark = 0;
  cLiquidityValue.destroy = (void (*)(void *)) free_FIX_LiquidityValue;
  cLiquidityValue.trackObjects = 0;
  
  cSecurityIDSource.klass = rb_define_class_under(mQuickfix, "SecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityIDSource, (void *) &cSecurityIDSource);
  rb_define_alloc_func(cSecurityIDSource.klass, _wrap_SecurityIDSource_allocate);
  rb_define_method(cSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_SecurityIDSource), -1);
  cSecurityIDSource.mark = 0;
  cSecurityIDSource.destroy = (void (*)(void *)) free_FIX_SecurityIDSource;
  cSecurityIDSource.trackObjects = 0;
  
  cNewsRefType.klass = rb_define_class_under(mQuickfix, "NewsRefType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewsRefType, (void *) &cNewsRefType);
  rb_define_alloc_func(cNewsRefType.klass, _wrap_NewsRefType_allocate);
  rb_define_method(cNewsRefType.klass, "initialize", VALUEFUNC(_wrap_new_NewsRefType), -1);
  cNewsRefType.mark = 0;
  cNewsRefType.destroy = (void (*)(void *)) free_FIX_NewsRefType;
  cNewsRefType.trackObjects = 0;
  
  cNoOfLegUnderlyings.klass = rb_define_class_under(mQuickfix, "NoOfLegUnderlyings", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOfLegUnderlyings, (void *) &cNoOfLegUnderlyings);
  rb_define_alloc_func(cNoOfLegUnderlyings.klass, _wrap_NoOfLegUnderlyings_allocate);
  rb_define_method(cNoOfLegUnderlyings.klass, "initialize", VALUEFUNC(_wrap_new_NoOfLegUnderlyings), -1);
  cNoOfLegUnderlyings.mark = 0;
  cNoOfLegUnderlyings.destroy = (void (*)(void *)) free_FIX_NoOfLegUnderlyings;
  cNoOfLegUnderlyings.trackObjects = 0;
  
  cDerivativeEncodedSecurityDesc.klass = rb_define_class_under(mQuickfix, "DerivativeEncodedSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc, (void *) &cDerivativeEncodedSecurityDesc);
  rb_define_alloc_func(cDerivativeEncodedSecurityDesc.klass, _wrap_DerivativeEncodedSecurityDesc_allocate);
  rb_define_method(cDerivativeEncodedSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeEncodedSecurityDesc), -1);
  cDerivativeEncodedSecurityDesc.mark = 0;
  cDerivativeEncodedSecurityDesc.destroy = (void (*)(void *)) free_FIX_DerivativeEncodedSecurityDesc;
  cDerivativeEncodedSecurityDesc.trackObjects = 0;
  
  cTriggerOrderType.klass = rb_define_class_under(mQuickfix, "TriggerOrderType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerOrderType, (void *) &cTriggerOrderType);
  rb_define_alloc_func(cTriggerOrderType.klass, _wrap_TriggerOrderType_allocate);
  rb_define_method(cTriggerOrderType.klass, "initialize", VALUEFUNC(_wrap_new_TriggerOrderType), -1);
  cTriggerOrderType.mark = 0;
  cTriggerOrderType.destroy = (void (*)(void *)) free_FIX_TriggerOrderType;
  cTriggerOrderType.trackObjects = 0;
  
  cUnderlyingDirtyPrice.klass = rb_define_class_under(mQuickfix, "UnderlyingDirtyPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingDirtyPrice, (void *) &cUnderlyingDirtyPrice);
  rb_define_alloc_func(cUnderlyingDirtyPrice.klass, _wrap_UnderlyingDirtyPrice_allocate);
  rb_define_method(cUnderlyingDirtyPrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingDirtyPrice), -1);
  cUnderlyingDirtyPrice.mark = 0;
  cUnderlyingDirtyPrice.destroy = (void (*)(void *)) free_FIX_UnderlyingDirtyPrice;
  cUnderlyingDirtyPrice.trackObjects = 0;
  
  cCrossType.klass = rb_define_class_under(mQuickfix, "CrossType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossType, (void *) &cCrossType);
  rb_define_alloc_func(cCrossType.klass, _wrap_CrossType_allocate);
  rb_define_method(cCrossType.klass, "initialize", VALUEFUNC(_wrap_new_CrossType), -1);
  cCrossType.mark = 0;
  cCrossType.destroy = (void (*)(void *)) free_FIX_CrossType;
  cCrossType.trackObjects = 0;
  
  cRepoCollateralSecurityType.klass = rb_define_class_under(mQuickfix, "RepoCollateralSecurityType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RepoCollateralSecurityType, (void *) &cRepoCollateralSecurityType);
  rb_define_alloc_func(cRepoCollateralSecurityType.klass, _wrap_RepoCollateralSecurityType_allocate);
  rb_define_method(cRepoCollateralSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_RepoCollateralSecurityType), -1);
  cRepoCollateralSecurityType.mark = 0;
  cRepoCollateralSecurityType.destroy = (void (*)(void *)) free_FIX_RepoCollateralSecurityType;
  cRepoCollateralSecurityType.trackObjects = 0;
  
  cPassword.klass = rb_define_class_under(mQuickfix, "Password", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Password, (void *) &cPassword);
  rb_define_alloc_func(cPassword.klass, _wrap_Password_allocate);
  rb_define_method(cPassword.klass, "initialize", VALUEFUNC(_wrap_new_Password), -1);
  cPassword.mark = 0;
  cPassword.destroy = (void (*)(void *)) free_FIX_Password;
  cPassword.trackObjects = 0;
  
  cOpenCloseSettleFlag.klass = rb_define_class_under(mQuickfix, "OpenCloseSettleFlag", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenCloseSettleFlag, (void *) &cOpenCloseSettleFlag);
  rb_define_alloc_func(cOpenCloseSettleFlag.klass, _wrap_OpenCloseSettleFlag_allocate);
  rb_define_method(cOpenCloseSettleFlag.klass, "initialize", VALUEFUNC(_wrap_new_OpenCloseSettleFlag), -1);
  cOpenCloseSettleFlag.mark = 0;
  cOpenCloseSettleFlag.destroy = (void (*)(void *)) free_FIX_OpenCloseSettleFlag;
  cOpenCloseSettleFlag.trackObjects = 0;
  
  cSubject.klass = rb_define_class_under(mQuickfix, "Subject", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Subject, (void *) &cSubject);
  rb_define_alloc_func(cSubject.klass, _wrap_Subject_allocate);
  rb_define_method(cSubject.klass, "initialize", VALUEFUNC(_wrap_new_Subject), -1);
  cSubject.mark = 0;
  cSubject.destroy = (void (*)(void *)) free_FIX_Subject;
  cSubject.trackObjects = 0;
  
  cRefApplReqID.klass = rb_define_class_under(mQuickfix, "RefApplReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplReqID, (void *) &cRefApplReqID);
  rb_define_alloc_func(cRefApplReqID.klass, _wrap_RefApplReqID_allocate);
  rb_define_method(cRefApplReqID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplReqID), -1);
  cRefApplReqID.mark = 0;
  cRefApplReqID.destroy = (void (*)(void *)) free_FIX_RefApplReqID;
  cRefApplReqID.trackObjects = 0;
  
  cUnderlyingEndValue.klass = rb_define_class_under(mQuickfix, "UnderlyingEndValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingEndValue, (void *) &cUnderlyingEndValue);
  rb_define_alloc_func(cUnderlyingEndValue.klass, _wrap_UnderlyingEndValue_allocate);
  rb_define_method(cUnderlyingEndValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingEndValue), -1);
  cUnderlyingEndValue.mark = 0;
  cUnderlyingEndValue.destroy = (void (*)(void *)) free_FIX_UnderlyingEndValue;
  cUnderlyingEndValue.trackObjects = 0;
  
  cNewSeqNo.klass = rb_define_class_under(mQuickfix, "NewSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NewSeqNo, (void *) &cNewSeqNo);
  rb_define_alloc_func(cNewSeqNo.klass, _wrap_NewSeqNo_allocate);
  rb_define_method(cNewSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_NewSeqNo), -1);
  cNewSeqNo.mark = 0;
  cNewSeqNo.destroy = (void (*)(void *)) free_FIX_NewSeqNo;
  cNewSeqNo.trackObjects = 0;
  
  cOrigTradeHandlingInstr.klass = rb_define_class_under(mQuickfix, "OrigTradeHandlingInstr", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTradeHandlingInstr, (void *) &cOrigTradeHandlingInstr);
  rb_define_alloc_func(cOrigTradeHandlingInstr.klass, _wrap_OrigTradeHandlingInstr_allocate);
  rb_define_method(cOrigTradeHandlingInstr.klass, "initialize", VALUEFUNC(_wrap_new_OrigTradeHandlingInstr), -1);
  cOrigTradeHandlingInstr.mark = 0;
  cOrigTradeHandlingInstr.destroy = (void (*)(void *)) free_FIX_OrigTradeHandlingInstr;
  cOrigTradeHandlingInstr.trackObjects = 0;
  
  cDisplayHighQty.klass = rb_define_class_under(mQuickfix, "DisplayHighQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayHighQty, (void *) &cDisplayHighQty);
  rb_define_alloc_func(cDisplayHighQty.klass, _wrap_DisplayHighQty_allocate);
  rb_define_method(cDisplayHighQty.klass, "initialize", VALUEFUNC(_wrap_new_DisplayHighQty), -1);
  cDisplayHighQty.mark = 0;
  cDisplayHighQty.destroy = (void (*)(void *)) free_FIX_DisplayHighQty;
  cDisplayHighQty.trackObjects = 0;
  
  cMDBookType.klass = rb_define_class_under(mQuickfix, "MDBookType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDBookType, (void *) &cMDBookType);
  rb_define_alloc_func(cMDBookType.klass, _wrap_MDBookType_allocate);
  rb_define_method(cMDBookType.klass, "initialize", VALUEFUNC(_wrap_new_MDBookType), -1);
  cMDBookType.mark = 0;
  cMDBookType.destroy = (void (*)(void *)) free_FIX_MDBookType;
  cMDBookType.trackObjects = 0;
  
  cMarginExcess.klass = rb_define_class_under(mQuickfix, "MarginExcess", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarginExcess, (void *) &cMarginExcess);
  rb_define_alloc_func(cMarginExcess.klass, _wrap_MarginExcess_allocate);
  rb_define_method(cMarginExcess.klass, "initialize", VALUEFUNC(_wrap_new_MarginExcess), -1);
  cMarginExcess.mark = 0;
  cMarginExcess.destroy = (void (*)(void *)) free_FIX_MarginExcess;
  cMarginExcess.trackObjects = 0;
  
  cBasisPxType.klass = rb_define_class_under(mQuickfix, "BasisPxType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BasisPxType, (void *) &cBasisPxType);
  rb_define_alloc_func(cBasisPxType.klass, _wrap_BasisPxType_allocate);
  rb_define_method(cBasisPxType.klass, "initialize", VALUEFUNC(_wrap_new_BasisPxType), -1);
  cBasisPxType.mark = 0;
  cBasisPxType.destroy = (void (*)(void *)) free_FIX_BasisPxType;
  cBasisPxType.trackObjects = 0;
  
  cDlvyInst.klass = rb_define_class_under(mQuickfix, "DlvyInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DlvyInst, (void *) &cDlvyInst);
  rb_define_alloc_func(cDlvyInst.klass, _wrap_DlvyInst_allocate);
  rb_define_method(cDlvyInst.klass, "initialize", VALUEFUNC(_wrap_new_DlvyInst), -1);
  cDlvyInst.mark = 0;
  cDlvyInst.destroy = (void (*)(void *)) free_FIX_DlvyInst;
  cDlvyInst.trackObjects = 0;
  
  cComplianceID.klass = rb_define_class_under(mQuickfix, "ComplianceID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplianceID, (void *) &cComplianceID);
  rb_define_alloc_func(cComplianceID.klass, _wrap_ComplianceID_allocate);
  rb_define_method(cComplianceID.klass, "initialize", VALUEFUNC(_wrap_new_ComplianceID), -1);
  cComplianceID.mark = 0;
  cComplianceID.destroy = (void (*)(void *)) free_FIX_ComplianceID;
  cComplianceID.trackObjects = 0;
  
  cEmailThreadID.klass = rb_define_class_under(mQuickfix, "EmailThreadID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EmailThreadID, (void *) &cEmailThreadID);
  rb_define_alloc_func(cEmailThreadID.klass, _wrap_EmailThreadID_allocate);
  rb_define_method(cEmailThreadID.klass, "initialize", VALUEFUNC(_wrap_new_EmailThreadID), -1);
  cEmailThreadID.mark = 0;
  cEmailThreadID.destroy = (void (*)(void *)) free_FIX_EmailThreadID;
  cEmailThreadID.trackObjects = 0;
  
  cContAmtCurr.klass = rb_define_class_under(mQuickfix, "ContAmtCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContAmtCurr, (void *) &cContAmtCurr);
  rb_define_alloc_func(cContAmtCurr.klass, _wrap_ContAmtCurr_allocate);
  rb_define_method(cContAmtCurr.klass, "initialize", VALUEFUNC(_wrap_new_ContAmtCurr), -1);
  cContAmtCurr.mark = 0;
  cContAmtCurr.destroy = (void (*)(void *)) free_FIX_ContAmtCurr;
  cContAmtCurr.trackObjects = 0;
  
  cRelationshipRiskSecurityGroup.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityGroup", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityGroup, (void *) &cRelationshipRiskSecurityGroup);
  rb_define_alloc_func(cRelationshipRiskSecurityGroup.klass, _wrap_RelationshipRiskSecurityGroup_allocate);
  rb_define_method(cRelationshipRiskSecurityGroup.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityGroup), -1);
  cRelationshipRiskSecurityGroup.mark = 0;
  cRelationshipRiskSecurityGroup.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityGroup;
  cRelationshipRiskSecurityGroup.trackObjects = 0;
  
  cComplexEventType.klass = rb_define_class_under(mQuickfix, "ComplexEventType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventType, (void *) &cComplexEventType);
  rb_define_alloc_func(cComplexEventType.klass, _wrap_ComplexEventType_allocate);
  rb_define_method(cComplexEventType.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventType), -1);
  cComplexEventType.mark = 0;
  cComplexEventType.destroy = (void (*)(void *)) free_FIX_ComplexEventType;
  cComplexEventType.trackObjects = 0;
  
  cMassActionResponse.klass = rb_define_class_under(mQuickfix, "MassActionResponse", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassActionResponse, (void *) &cMassActionResponse);
  rb_define_alloc_func(cMassActionResponse.klass, _wrap_MassActionResponse_allocate);
  rb_define_method(cMassActionResponse.klass, "initialize", VALUEFUNC(_wrap_new_MassActionResponse), -1);
  cMassActionResponse.mark = 0;
  cMassActionResponse.destroy = (void (*)(void *)) free_FIX_MassActionResponse;
  cMassActionResponse.trackObjects = 0;
  
  cUnderlyingIssueDate.klass = rb_define_class_under(mQuickfix, "UnderlyingIssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingIssueDate, (void *) &cUnderlyingIssueDate);
  rb_define_alloc_func(cUnderlyingIssueDate.klass, _wrap_UnderlyingIssueDate_allocate);
  rb_define_method(cUnderlyingIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingIssueDate), -1);
  cUnderlyingIssueDate.mark = 0;
  cUnderlyingIssueDate.destroy = (void (*)(void *)) free_FIX_UnderlyingIssueDate;
  cUnderlyingIssueDate.trackObjects = 0;
  
  cSecurityRequestType.klass = rb_define_class_under(mQuickfix, "SecurityRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityRequestType, (void *) &cSecurityRequestType);
  rb_define_alloc_func(cSecurityRequestType.klass, _wrap_SecurityRequestType_allocate);
  rb_define_method(cSecurityRequestType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityRequestType), -1);
  cSecurityRequestType.mark = 0;
  cSecurityRequestType.destroy = (void (*)(void *)) free_FIX_SecurityRequestType;
  cSecurityRequestType.trackObjects = 0;
  
  cAllocInterestAtMaturity.klass = rb_define_class_under(mQuickfix, "AllocInterestAtMaturity", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocInterestAtMaturity, (void *) &cAllocInterestAtMaturity);
  rb_define_alloc_func(cAllocInterestAtMaturity.klass, _wrap_AllocInterestAtMaturity_allocate);
  rb_define_method(cAllocInterestAtMaturity.klass, "initialize", VALUEFUNC(_wrap_new_AllocInterestAtMaturity), -1);
  cAllocInterestAtMaturity.mark = 0;
  cAllocInterestAtMaturity.destroy = (void (*)(void *)) free_FIX_AllocInterestAtMaturity;
  cAllocInterestAtMaturity.trackObjects = 0;
  
  cListRejectReason.klass = rb_define_class_under(mQuickfix, "ListRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListRejectReason, (void *) &cListRejectReason);
  rb_define_alloc_func(cListRejectReason.klass, _wrap_ListRejectReason_allocate);
  rb_define_method(cListRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_ListRejectReason), -1);
  cListRejectReason.mark = 0;
  cListRejectReason.destroy = (void (*)(void *)) free_FIX_ListRejectReason;
  cListRejectReason.trackObjects = 0;
  
  cDeskType.klass = rb_define_class_under(mQuickfix, "DeskType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskType, (void *) &cDeskType);
  rb_define_alloc_func(cDeskType.klass, _wrap_DeskType_allocate);
  rb_define_method(cDeskType.klass, "initialize", VALUEFUNC(_wrap_new_DeskType), -1);
  cDeskType.mark = 0;
  cDeskType.destroy = (void (*)(void *)) free_FIX_DeskType;
  cDeskType.trackObjects = 0;
  
  cSecondaryTradeReportID.klass = rb_define_class_under(mQuickfix, "SecondaryTradeReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradeReportID, (void *) &cSecondaryTradeReportID);
  rb_define_alloc_func(cSecondaryTradeReportID.klass, _wrap_SecondaryTradeReportID_allocate);
  rb_define_method(cSecondaryTradeReportID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradeReportID), -1);
  cSecondaryTradeReportID.mark = 0;
  cSecondaryTradeReportID.destroy = (void (*)(void *)) free_FIX_SecondaryTradeReportID;
  cSecondaryTradeReportID.trackObjects = 0;
  
  cSettlType.klass = rb_define_class_under(mQuickfix, "SettlType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlType, (void *) &cSettlType);
  rb_define_alloc_func(cSettlType.klass, _wrap_SettlType_allocate);
  rb_define_method(cSettlType.klass, "initialize", VALUEFUNC(_wrap_new_SettlType), -1);
  cSettlType.mark = 0;
  cSettlType.destroy = (void (*)(void *)) free_FIX_SettlType;
  cSettlType.trackObjects = 0;
  
  cOpenClose.klass = rb_define_class_under(mQuickfix, "OpenClose", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OpenClose, (void *) &cOpenClose);
  rb_define_alloc_func(cOpenClose.klass, _wrap_OpenClose_allocate);
  rb_define_method(cOpenClose.klass, "initialize", VALUEFUNC(_wrap_new_OpenClose), -1);
  cOpenClose.mark = 0;
  cOpenClose.destroy = (void (*)(void *)) free_FIX_OpenClose;
  cOpenClose.trackObjects = 0;
  
  cContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "ContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContractMultiplierUnit, (void *) &cContractMultiplierUnit);
  rb_define_alloc_func(cContractMultiplierUnit.klass, _wrap_ContractMultiplierUnit_allocate);
  rb_define_method(cContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_ContractMultiplierUnit), -1);
  cContractMultiplierUnit.mark = 0;
  cContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_ContractMultiplierUnit;
  cContractMultiplierUnit.trackObjects = 0;
  
  cSecondaryLowLimitPrice.klass = rb_define_class_under(mQuickfix, "SecondaryLowLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryLowLimitPrice, (void *) &cSecondaryLowLimitPrice);
  rb_define_alloc_func(cSecondaryLowLimitPrice.klass, _wrap_SecondaryLowLimitPrice_allocate);
  rb_define_method(cSecondaryLowLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryLowLimitPrice), -1);
  cSecondaryLowLimitPrice.mark = 0;
  cSecondaryLowLimitPrice.destroy = (void (*)(void *)) free_FIX_SecondaryLowLimitPrice;
  cSecondaryLowLimitPrice.trackObjects = 0;
  
  cExpQty.klass = rb_define_class_under(mQuickfix, "ExpQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExpQty, (void *) &cExpQty);
  rb_define_alloc_func(cExpQty.klass, _wrap_ExpQty_allocate);
  rb_define_method(cExpQty.klass, "initialize", VALUEFUNC(_wrap_new_ExpQty), -1);
  cExpQty.mark = 0;
  cExpQty.destroy = (void (*)(void *)) free_FIX_ExpQty;
  cExpQty.trackObjects = 0;
  
  cNetworkRequestID.klass = rb_define_class_under(mQuickfix, "NetworkRequestID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkRequestID, (void *) &cNetworkRequestID);
  rb_define_alloc_func(cNetworkRequestID.klass, _wrap_NetworkRequestID_allocate);
  rb_define_method(cNetworkRequestID.klass, "initialize", VALUEFUNC(_wrap_new_NetworkRequestID), -1);
  cNetworkRequestID.mark = 0;
  cNetworkRequestID.destroy = (void (*)(void *)) free_FIX_NetworkRequestID;
  cNetworkRequestID.trackObjects = 0;
  
  cTrdType.klass = rb_define_class_under(mQuickfix, "TrdType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdType, (void *) &cTrdType);
  rb_define_alloc_func(cTrdType.klass, _wrap_TrdType_allocate);
  rb_define_method(cTrdType.klass, "initialize", VALUEFUNC(_wrap_new_TrdType), -1);
  cTrdType.mark = 0;
  cTrdType.destroy = (void (*)(void *)) free_FIX_TrdType;
  cTrdType.trackObjects = 0;
  
  cNoUnderlyings.klass = rb_define_class_under(mQuickfix, "NoUnderlyings", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyings, (void *) &cNoUnderlyings);
  rb_define_alloc_func(cNoUnderlyings.klass, _wrap_NoUnderlyings_allocate);
  rb_define_method(cNoUnderlyings.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyings), -1);
  cNoUnderlyings.mark = 0;
  cNoUnderlyings.destroy = (void (*)(void *)) free_FIX_NoUnderlyings;
  cNoUnderlyings.trackObjects = 0;
  
  cMDMkt.klass = rb_define_class_under(mQuickfix, "MDMkt", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDMkt, (void *) &cMDMkt);
  rb_define_alloc_func(cMDMkt.klass, _wrap_MDMkt_allocate);
  rb_define_method(cMDMkt.klass, "initialize", VALUEFUNC(_wrap_new_MDMkt), -1);
  cMDMkt.mark = 0;
  cMDMkt.destroy = (void (*)(void *)) free_FIX_MDMkt;
  cMDMkt.trackObjects = 0;
  
  cLastMkt.klass = rb_define_class_under(mQuickfix, "LastMkt", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastMkt, (void *) &cLastMkt);
  rb_define_alloc_func(cLastMkt.klass, _wrap_LastMkt_allocate);
  rb_define_method(cLastMkt.klass, "initialize", VALUEFUNC(_wrap_new_LastMkt), -1);
  cLastMkt.mark = 0;
  cLastMkt.destroy = (void (*)(void *)) free_FIX_LastMkt;
  cLastMkt.trackObjects = 0;
  
  cRestructuringType.klass = rb_define_class_under(mQuickfix, "RestructuringType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RestructuringType, (void *) &cRestructuringType);
  rb_define_alloc_func(cRestructuringType.klass, _wrap_RestructuringType_allocate);
  rb_define_method(cRestructuringType.klass, "initialize", VALUEFUNC(_wrap_new_RestructuringType), -1);
  cRestructuringType.mark = 0;
  cRestructuringType.destroy = (void (*)(void *)) free_FIX_RestructuringType;
  cRestructuringType.trackObjects = 0;
  
  cNoStrikeRules.klass = rb_define_class_under(mQuickfix, "NoStrikeRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStrikeRules, (void *) &cNoStrikeRules);
  rb_define_alloc_func(cNoStrikeRules.klass, _wrap_NoStrikeRules_allocate);
  rb_define_method(cNoStrikeRules.klass, "initialize", VALUEFUNC(_wrap_new_NoStrikeRules), -1);
  cNoStrikeRules.mark = 0;
  cNoStrikeRules.destroy = (void (*)(void *)) free_FIX_NoStrikeRules;
  cNoStrikeRules.trackObjects = 0;
  
  cListName.klass = rb_define_class_under(mQuickfix, "ListName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListName, (void *) &cListName);
  rb_define_alloc_func(cListName.klass, _wrap_ListName_allocate);
  rb_define_method(cListName.klass, "initialize", VALUEFUNC(_wrap_new_ListName), -1);
  cListName.mark = 0;
  cListName.destroy = (void (*)(void *)) free_FIX_ListName;
  cListName.trackObjects = 0;
  
  cProgRptReqs.klass = rb_define_class_under(mQuickfix, "ProgRptReqs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProgRptReqs, (void *) &cProgRptReqs);
  rb_define_alloc_func(cProgRptReqs.klass, _wrap_ProgRptReqs_allocate);
  rb_define_method(cProgRptReqs.klass, "initialize", VALUEFUNC(_wrap_new_ProgRptReqs), -1);
  cProgRptReqs.mark = 0;
  cProgRptReqs.destroy = (void (*)(void *)) free_FIX_ProgRptReqs;
  cProgRptReqs.trackObjects = 0;
  
  cTradingSessionID.klass = rb_define_class_under(mQuickfix, "TradingSessionID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingSessionID, (void *) &cTradingSessionID);
  rb_define_alloc_func(cTradingSessionID.klass, _wrap_TradingSessionID_allocate);
  rb_define_method(cTradingSessionID.klass, "initialize", VALUEFUNC(_wrap_new_TradingSessionID), -1);
  cTradingSessionID.mark = 0;
  cTradingSessionID.destroy = (void (*)(void *)) free_FIX_TradingSessionID;
  cTradingSessionID.trackObjects = 0;
  
  cListOrderStatus.klass = rb_define_class_under(mQuickfix, "ListOrderStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListOrderStatus, (void *) &cListOrderStatus);
  rb_define_alloc_func(cListOrderStatus.klass, _wrap_ListOrderStatus_allocate);
  rb_define_method(cListOrderStatus.klass, "initialize", VALUEFUNC(_wrap_new_ListOrderStatus), -1);
  cListOrderStatus.mark = 0;
  cListOrderStatus.destroy = (void (*)(void *)) free_FIX_ListOrderStatus;
  cListOrderStatus.trackObjects = 0;
  
  cRegistStatus.klass = rb_define_class_under(mQuickfix, "RegistStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistStatus, (void *) &cRegistStatus);
  rb_define_alloc_func(cRegistStatus.klass, _wrap_RegistStatus_allocate);
  rb_define_method(cRegistStatus.klass, "initialize", VALUEFUNC(_wrap_new_RegistStatus), -1);
  cRegistStatus.mark = 0;
  cRegistStatus.destroy = (void (*)(void *)) free_FIX_RegistStatus;
  cRegistStatus.trackObjects = 0;
  
  cPosAmt.klass = rb_define_class_under(mQuickfix, "PosAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosAmt, (void *) &cPosAmt);
  rb_define_alloc_func(cPosAmt.klass, _wrap_PosAmt_allocate);
  rb_define_method(cPosAmt.klass, "initialize", VALUEFUNC(_wrap_new_PosAmt), -1);
  cPosAmt.mark = 0;
  cPosAmt.destroy = (void (*)(void *)) free_FIX_PosAmt;
  cPosAmt.trackObjects = 0;
  
  cUnderlyingPriceDeterminationMethod.klass = rb_define_class_under(mQuickfix, "UnderlyingPriceDeterminationMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod, (void *) &cUnderlyingPriceDeterminationMethod);
  rb_define_alloc_func(cUnderlyingPriceDeterminationMethod.klass, _wrap_UnderlyingPriceDeterminationMethod_allocate);
  rb_define_method(cUnderlyingPriceDeterminationMethod.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPriceDeterminationMethod), -1);
  cUnderlyingPriceDeterminationMethod.mark = 0;
  cUnderlyingPriceDeterminationMethod.destroy = (void (*)(void *)) free_FIX_UnderlyingPriceDeterminationMethod;
  cUnderlyingPriceDeterminationMethod.trackObjects = 0;
  
  cNoUnderlyingStips.klass = rb_define_class_under(mQuickfix, "NoUnderlyingStips", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingStips, (void *) &cNoUnderlyingStips);
  rb_define_alloc_func(cNoUnderlyingStips.klass, _wrap_NoUnderlyingStips_allocate);
  rb_define_method(cNoUnderlyingStips.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingStips), -1);
  cNoUnderlyingStips.mark = 0;
  cNoUnderlyingStips.destroy = (void (*)(void *)) free_FIX_NoUnderlyingStips;
  cNoUnderlyingStips.trackObjects = 0;
  
  cTradSesPreCloseTime.klass = rb_define_class_under(mQuickfix, "TradSesPreCloseTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesPreCloseTime, (void *) &cTradSesPreCloseTime);
  rb_define_alloc_func(cTradSesPreCloseTime.klass, _wrap_TradSesPreCloseTime_allocate);
  rb_define_method(cTradSesPreCloseTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesPreCloseTime), -1);
  cTradSesPreCloseTime.mark = 0;
  cTradSesPreCloseTime.destroy = (void (*)(void *)) free_FIX_TradSesPreCloseTime;
  cTradSesPreCloseTime.trackObjects = 0;
  
  cMassCancelRequestType.klass = rb_define_class_under(mQuickfix, "MassCancelRequestType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassCancelRequestType, (void *) &cMassCancelRequestType);
  rb_define_alloc_func(cMassCancelRequestType.klass, _wrap_MassCancelRequestType_allocate);
  rb_define_method(cMassCancelRequestType.klass, "initialize", VALUEFUNC(_wrap_new_MassCancelRequestType), -1);
  cMassCancelRequestType.mark = 0;
  cMassCancelRequestType.destroy = (void (*)(void *)) free_FIX_MassCancelRequestType;
  cMassCancelRequestType.trackObjects = 0;
  
  cUnderlyingLegSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource, (void *) &cUnderlyingLegSecurityAltIDSource);
  rb_define_alloc_func(cUnderlyingLegSecurityAltIDSource.klass, _wrap_UnderlyingLegSecurityAltIDSource_allocate);
  rb_define_method(cUnderlyingLegSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityAltIDSource), -1);
  cUnderlyingLegSecurityAltIDSource.mark = 0;
  cUnderlyingLegSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityAltIDSource;
  cUnderlyingLegSecurityAltIDSource.trackObjects = 0;
  
  cSettlPartyID.klass = rb_define_class_under(mQuickfix, "SettlPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartyID, (void *) &cSettlPartyID);
  rb_define_alloc_func(cSettlPartyID.klass, _wrap_SettlPartyID_allocate);
  rb_define_method(cSettlPartyID.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartyID), -1);
  cSettlPartyID.mark = 0;
  cSettlPartyID.destroy = (void (*)(void *)) free_FIX_SettlPartyID;
  cSettlPartyID.trackObjects = 0;
  
  cNoAffectedOrders.klass = rb_define_class_under(mQuickfix, "NoAffectedOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAffectedOrders, (void *) &cNoAffectedOrders);
  rb_define_alloc_func(cNoAffectedOrders.klass, _wrap_NoAffectedOrders_allocate);
  rb_define_method(cNoAffectedOrders.klass, "initialize", VALUEFUNC(_wrap_new_NoAffectedOrders), -1);
  cNoAffectedOrders.mark = 0;
  cNoAffectedOrders.destroy = (void (*)(void *)) free_FIX_NoAffectedOrders;
  cNoAffectedOrders.trackObjects = 0;
  
  cCashSettlAgentAcctNum.klass = rb_define_class_under(mQuickfix, "CashSettlAgentAcctNum", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentAcctNum, (void *) &cCashSettlAgentAcctNum);
  rb_define_alloc_func(cCashSettlAgentAcctNum.klass, _wrap_CashSettlAgentAcctNum_allocate);
  rb_define_method(cCashSettlAgentAcctNum.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentAcctNum), -1);
  cCashSettlAgentAcctNum.mark = 0;
  cCashSettlAgentAcctNum.destroy = (void (*)(void *)) free_FIX_CashSettlAgentAcctNum;
  cCashSettlAgentAcctNum.trackObjects = 0;
  
  cUnderlyingLegMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "UnderlyingLegMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear, (void *) &cUnderlyingLegMaturityMonthYear);
  rb_define_alloc_func(cUnderlyingLegMaturityMonthYear.klass, _wrap_UnderlyingLegMaturityMonthYear_allocate);
  rb_define_method(cUnderlyingLegMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegMaturityMonthYear), -1);
  cUnderlyingLegMaturityMonthYear.mark = 0;
  cUnderlyingLegMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_UnderlyingLegMaturityMonthYear;
  cUnderlyingLegMaturityMonthYear.trackObjects = 0;
  
  cDerivativeSecurityListRequestType.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityListRequestType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityListRequestType, (void *) &cDerivativeSecurityListRequestType);
  rb_define_alloc_func(cDerivativeSecurityListRequestType.klass, _wrap_DerivativeSecurityListRequestType_allocate);
  rb_define_method(cDerivativeSecurityListRequestType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityListRequestType), -1);
  cDerivativeSecurityListRequestType.mark = 0;
  cDerivativeSecurityListRequestType.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityListRequestType;
  cDerivativeSecurityListRequestType.trackObjects = 0;
  
  cNoLotTypeRules.klass = rb_define_class_under(mQuickfix, "NoLotTypeRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLotTypeRules, (void *) &cNoLotTypeRules);
  rb_define_alloc_func(cNoLotTypeRules.klass, _wrap_NoLotTypeRules_allocate);
  rb_define_method(cNoLotTypeRules.klass, "initialize", VALUEFUNC(_wrap_new_NoLotTypeRules), -1);
  cNoLotTypeRules.mark = 0;
  cNoLotTypeRules.destroy = (void (*)(void *)) free_FIX_NoLotTypeRules;
  cNoLotTypeRules.trackObjects = 0;
  
  cNoDates.klass = rb_define_class_under(mQuickfix, "NoDates", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDates, (void *) &cNoDates);
  rb_define_alloc_func(cNoDates.klass, _wrap_NoDates_allocate);
  rb_define_method(cNoDates.klass, "initialize", VALUEFUNC(_wrap_new_NoDates), -1);
  cNoDates.mark = 0;
  cNoDates.destroy = (void (*)(void *)) free_FIX_NoDates;
  cNoDates.trackObjects = 0;
  
  cCxlRejResponseTo.klass = rb_define_class_under(mQuickfix, "CxlRejResponseTo", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlRejResponseTo, (void *) &cCxlRejResponseTo);
  rb_define_alloc_func(cCxlRejResponseTo.klass, _wrap_CxlRejResponseTo_allocate);
  rb_define_method(cCxlRejResponseTo.klass, "initialize", VALUEFUNC(_wrap_new_CxlRejResponseTo), -1);
  cCxlRejResponseTo.mark = 0;
  cCxlRejResponseTo.destroy = (void (*)(void *)) free_FIX_CxlRejResponseTo;
  cCxlRejResponseTo.trackObjects = 0;
  
  cEffectiveTime.klass = rb_define_class_under(mQuickfix, "EffectiveTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EffectiveTime, (void *) &cEffectiveTime);
  rb_define_alloc_func(cEffectiveTime.klass, _wrap_EffectiveTime_allocate);
  rb_define_method(cEffectiveTime.klass, "initialize", VALUEFUNC(_wrap_new_EffectiveTime), -1);
  cEffectiveTime.mark = 0;
  cEffectiveTime.destroy = (void (*)(void *)) free_FIX_EffectiveTime;
  cEffectiveTime.trackObjects = 0;
  
  cGrossTradeAmt.klass = rb_define_class_under(mQuickfix, "GrossTradeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__GrossTradeAmt, (void *) &cGrossTradeAmt);
  rb_define_alloc_func(cGrossTradeAmt.klass, _wrap_GrossTradeAmt_allocate);
  rb_define_method(cGrossTradeAmt.klass, "initialize", VALUEFUNC(_wrap_new_GrossTradeAmt), -1);
  cGrossTradeAmt.mark = 0;
  cGrossTradeAmt.destroy = (void (*)(void *)) free_FIX_GrossTradeAmt;
  cGrossTradeAmt.trackObjects = 0;
  
  cContextPartyID.klass = rb_define_class_under(mQuickfix, "ContextPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContextPartyID, (void *) &cContextPartyID);
  rb_define_alloc_func(cContextPartyID.klass, _wrap_ContextPartyID_allocate);
  rb_define_method(cContextPartyID.klass, "initialize", VALUEFUNC(_wrap_new_ContextPartyID), -1);
  cContextPartyID.mark = 0;
  cContextPartyID.destroy = (void (*)(void *)) free_FIX_ContextPartyID;
  cContextPartyID.trackObjects = 0;
  
  cSecurityListDesc.klass = rb_define_class_under(mQuickfix, "SecurityListDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityListDesc, (void *) &cSecurityListDesc);
  rb_define_alloc_func(cSecurityListDesc.klass, _wrap_SecurityListDesc_allocate);
  rb_define_method(cSecurityListDesc.klass, "initialize", VALUEFUNC(_wrap_new_SecurityListDesc), -1);
  cSecurityListDesc.mark = 0;
  cSecurityListDesc.destroy = (void (*)(void *)) free_FIX_SecurityListDesc;
  cSecurityListDesc.trackObjects = 0;
  
  cNotAffectedOrderID.klass = rb_define_class_under(mQuickfix, "NotAffectedOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotAffectedOrderID, (void *) &cNotAffectedOrderID);
  rb_define_alloc_func(cNotAffectedOrderID.klass, _wrap_NotAffectedOrderID_allocate);
  rb_define_method(cNotAffectedOrderID.klass, "initialize", VALUEFUNC(_wrap_new_NotAffectedOrderID), -1);
  cNotAffectedOrderID.mark = 0;
  cNotAffectedOrderID.destroy = (void (*)(void *)) free_FIX_NotAffectedOrderID;
  cNotAffectedOrderID.trackObjects = 0;
  
  cDerivativeStrikeValue.klass = rb_define_class_under(mQuickfix, "DerivativeStrikeValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikeValue, (void *) &cDerivativeStrikeValue);
  rb_define_alloc_func(cDerivativeStrikeValue.klass, _wrap_DerivativeStrikeValue_allocate);
  rb_define_method(cDerivativeStrikeValue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikeValue), -1);
  cDerivativeStrikeValue.mark = 0;
  cDerivativeStrikeValue.destroy = (void (*)(void *)) free_FIX_DerivativeStrikeValue;
  cDerivativeStrikeValue.trackObjects = 0;
  
  cNoPosAmt.klass = rb_define_class_under(mQuickfix, "NoPosAmt", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPosAmt, (void *) &cNoPosAmt);
  rb_define_alloc_func(cNoPosAmt.klass, _wrap_NoPosAmt_allocate);
  rb_define_method(cNoPosAmt.klass, "initialize", VALUEFUNC(_wrap_new_NoPosAmt), -1);
  cNoPosAmt.mark = 0;
  cNoPosAmt.destroy = (void (*)(void *)) free_FIX_NoPosAmt;
  cNoPosAmt.trackObjects = 0;
  
  cLegCreditRating.klass = rb_define_class_under(mQuickfix, "LegCreditRating", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCreditRating, (void *) &cLegCreditRating);
  rb_define_alloc_func(cLegCreditRating.klass, _wrap_LegCreditRating_allocate);
  rb_define_method(cLegCreditRating.klass, "initialize", VALUEFUNC(_wrap_new_LegCreditRating), -1);
  cLegCreditRating.mark = 0;
  cLegCreditRating.destroy = (void (*)(void *)) free_FIX_LegCreditRating;
  cLegCreditRating.trackObjects = 0;
  
  cRelationshipRiskInstrumentSettlType.klass = rb_define_class_under(mQuickfix, "RelationshipRiskInstrumentSettlType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskInstrumentSettlType, (void *) &cRelationshipRiskInstrumentSettlType);
  rb_define_alloc_func(cRelationshipRiskInstrumentSettlType.klass, _wrap_RelationshipRiskInstrumentSettlType_allocate);
  rb_define_method(cRelationshipRiskInstrumentSettlType.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskInstrumentSettlType), -1);
  cRelationshipRiskInstrumentSettlType.mark = 0;
  cRelationshipRiskInstrumentSettlType.destroy = (void (*)(void *)) free_FIX_RelationshipRiskInstrumentSettlType;
  cRelationshipRiskInstrumentSettlType.trackObjects = 0;
  
  cBidForwardPoints2.klass = rb_define_class_under(mQuickfix, "BidForwardPoints2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidForwardPoints2, (void *) &cBidForwardPoints2);
  rb_define_alloc_func(cBidForwardPoints2.klass, _wrap_BidForwardPoints2_allocate);
  rb_define_method(cBidForwardPoints2.klass, "initialize", VALUEFUNC(_wrap_new_BidForwardPoints2), -1);
  cBidForwardPoints2.mark = 0;
  cBidForwardPoints2.destroy = (void (*)(void *)) free_FIX_BidForwardPoints2;
  cBidForwardPoints2.trackObjects = 0;
  
  cSettlDate.klass = rb_define_class_under(mQuickfix, "SettlDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDate, (void *) &cSettlDate);
  rb_define_alloc_func(cSettlDate.klass, _wrap_SettlDate_allocate);
  rb_define_method(cSettlDate.klass, "initialize", VALUEFUNC(_wrap_new_SettlDate), -1);
  cSettlDate.mark = 0;
  cSettlDate.destroy = (void (*)(void *)) free_FIX_SettlDate;
  cSettlDate.trackObjects = 0;
  
  cClientID.klass = rb_define_class_under(mQuickfix, "ClientID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClientID, (void *) &cClientID);
  rb_define_alloc_func(cClientID.klass, _wrap_ClientID_allocate);
  rb_define_method(cClientID.klass, "initialize", VALUEFUNC(_wrap_new_ClientID), -1);
  cClientID.mark = 0;
  cClientID.destroy = (void (*)(void *)) free_FIX_ClientID;
  cClientID.trackObjects = 0;
  
  cQuoteCancelType.klass = rb_define_class_under(mQuickfix, "QuoteCancelType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteCancelType, (void *) &cQuoteCancelType);
  rb_define_alloc_func(cQuoteCancelType.klass, _wrap_QuoteCancelType_allocate);
  rb_define_method(cQuoteCancelType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteCancelType), -1);
  cQuoteCancelType.mark = 0;
  cQuoteCancelType.destroy = (void (*)(void *)) free_FIX_QuoteCancelType;
  cQuoteCancelType.trackObjects = 0;
  
  cStipulationType.klass = rb_define_class_under(mQuickfix, "StipulationType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StipulationType, (void *) &cStipulationType);
  rb_define_alloc_func(cStipulationType.klass, _wrap_StipulationType_allocate);
  rb_define_method(cStipulationType.klass, "initialize", VALUEFUNC(_wrap_new_StipulationType), -1);
  cStipulationType.mark = 0;
  cStipulationType.destroy = (void (*)(void *)) free_FIX_StipulationType;
  cStipulationType.trackObjects = 0;
  
  cOutMainCntryUIndex.klass = rb_define_class_under(mQuickfix, "OutMainCntryUIndex", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OutMainCntryUIndex, (void *) &cOutMainCntryUIndex);
  rb_define_alloc_func(cOutMainCntryUIndex.klass, _wrap_OutMainCntryUIndex_allocate);
  rb_define_method(cOutMainCntryUIndex.klass, "initialize", VALUEFUNC(_wrap_new_OutMainCntryUIndex), -1);
  cOutMainCntryUIndex.mark = 0;
  cOutMainCntryUIndex.destroy = (void (*)(void *)) free_FIX_OutMainCntryUIndex;
  cOutMainCntryUIndex.trackObjects = 0;
  
  cLegSettlmntTyp.klass = rb_define_class_under(mQuickfix, "LegSettlmntTyp", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlmntTyp, (void *) &cLegSettlmntTyp);
  rb_define_alloc_func(cLegSettlmntTyp.klass, _wrap_LegSettlmntTyp_allocate);
  rb_define_method(cLegSettlmntTyp.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlmntTyp), -1);
  cLegSettlmntTyp.mark = 0;
  cLegSettlmntTyp.destroy = (void (*)(void *)) free_FIX_LegSettlmntTyp;
  cLegSettlmntTyp.trackObjects = 0;
  
  cNoRelationshipRiskInstruments.klass = rb_define_class_under(mQuickfix, "NoRelationshipRiskInstruments", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelationshipRiskInstruments, (void *) &cNoRelationshipRiskInstruments);
  rb_define_alloc_func(cNoRelationshipRiskInstruments.klass, _wrap_NoRelationshipRiskInstruments_allocate);
  rb_define_method(cNoRelationshipRiskInstruments.klass, "initialize", VALUEFUNC(_wrap_new_NoRelationshipRiskInstruments), -1);
  cNoRelationshipRiskInstruments.mark = 0;
  cNoRelationshipRiskInstruments.destroy = (void (*)(void *)) free_FIX_NoRelationshipRiskInstruments;
  cNoRelationshipRiskInstruments.trackObjects = 0;
  
  cDerivativeNTPositionLimit.klass = rb_define_class_under(mQuickfix, "DerivativeNTPositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeNTPositionLimit, (void *) &cDerivativeNTPositionLimit);
  rb_define_alloc_func(cDerivativeNTPositionLimit.klass, _wrap_DerivativeNTPositionLimit_allocate);
  rb_define_method(cDerivativeNTPositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeNTPositionLimit), -1);
  cDerivativeNTPositionLimit.mark = 0;
  cDerivativeNTPositionLimit.destroy = (void (*)(void *)) free_FIX_DerivativeNTPositionLimit;
  cDerivativeNTPositionLimit.trackObjects = 0;
  
  cPriceQuoteMethod.klass = rb_define_class_under(mQuickfix, "PriceQuoteMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceQuoteMethod, (void *) &cPriceQuoteMethod);
  rb_define_alloc_func(cPriceQuoteMethod.klass, _wrap_PriceQuoteMethod_allocate);
  rb_define_method(cPriceQuoteMethod.klass, "initialize", VALUEFUNC(_wrap_new_PriceQuoteMethod), -1);
  cPriceQuoteMethod.mark = 0;
  cPriceQuoteMethod.destroy = (void (*)(void *)) free_FIX_PriceQuoteMethod;
  cPriceQuoteMethod.trackObjects = 0;
  
  cLowLimitPrice.klass = rb_define_class_under(mQuickfix, "LowLimitPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LowLimitPrice, (void *) &cLowLimitPrice);
  rb_define_alloc_func(cLowLimitPrice.klass, _wrap_LowLimitPrice_allocate);
  rb_define_method(cLowLimitPrice.klass, "initialize", VALUEFUNC(_wrap_new_LowLimitPrice), -1);
  cLowLimitPrice.mark = 0;
  cLowLimitPrice.destroy = (void (*)(void *)) free_FIX_LowLimitPrice;
  cLowLimitPrice.trackObjects = 0;
  
  cLegUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "LegUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegUnitOfMeasure, (void *) &cLegUnitOfMeasure);
  rb_define_alloc_func(cLegUnitOfMeasure.klass, _wrap_LegUnitOfMeasure_allocate);
  rb_define_method(cLegUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_LegUnitOfMeasure), -1);
  cLegUnitOfMeasure.mark = 0;
  cLegUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_LegUnitOfMeasure;
  cLegUnitOfMeasure.trackObjects = 0;
  
  cSessionRejectReason.klass = rb_define_class_under(mQuickfix, "SessionRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionRejectReason, (void *) &cSessionRejectReason);
  rb_define_alloc_func(cSessionRejectReason.klass, _wrap_SessionRejectReason_allocate);
  rb_define_method(cSessionRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_SessionRejectReason), -1);
  cSessionRejectReason.mark = 0;
  cSessionRejectReason.destroy = (void (*)(void *)) free_FIX_SessionRejectReason;
  cSessionRejectReason.trackObjects = 0;
  
  cPartyDetailsListReportID.klass = rb_define_class_under(mQuickfix, "PartyDetailsListReportID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyDetailsListReportID, (void *) &cPartyDetailsListReportID);
  rb_define_alloc_func(cPartyDetailsListReportID.klass, _wrap_PartyDetailsListReportID_allocate);
  rb_define_method(cPartyDetailsListReportID.klass, "initialize", VALUEFUNC(_wrap_new_PartyDetailsListReportID), -1);
  cPartyDetailsListReportID.mark = 0;
  cPartyDetailsListReportID.destroy = (void (*)(void *)) free_FIX_PartyDetailsListReportID;
  cPartyDetailsListReportID.trackObjects = 0;
  
  cDeliveryType.klass = rb_define_class_under(mQuickfix, "DeliveryType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliveryType, (void *) &cDeliveryType);
  rb_define_alloc_func(cDeliveryType.klass, _wrap_DeliveryType_allocate);
  rb_define_method(cDeliveryType.klass, "initialize", VALUEFUNC(_wrap_new_DeliveryType), -1);
  cDeliveryType.mark = 0;
  cDeliveryType.destroy = (void (*)(void *)) free_FIX_DeliveryType;
  cDeliveryType.trackObjects = 0;
  
  cAllocPrice.klass = rb_define_class_under(mQuickfix, "AllocPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocPrice, (void *) &cAllocPrice);
  rb_define_alloc_func(cAllocPrice.klass, _wrap_AllocPrice_allocate);
  rb_define_method(cAllocPrice.klass, "initialize", VALUEFUNC(_wrap_new_AllocPrice), -1);
  cAllocPrice.mark = 0;
  cAllocPrice.destroy = (void (*)(void *)) free_FIX_AllocPrice;
  cAllocPrice.trackObjects = 0;
  
  cNoBidComponents.klass = rb_define_class_under(mQuickfix, "NoBidComponents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoBidComponents, (void *) &cNoBidComponents);
  rb_define_alloc_func(cNoBidComponents.klass, _wrap_NoBidComponents_allocate);
  rb_define_method(cNoBidComponents.klass, "initialize", VALUEFUNC(_wrap_new_NoBidComponents), -1);
  cNoBidComponents.mark = 0;
  cNoBidComponents.destroy = (void (*)(void *)) free_FIX_NoBidComponents;
  cNoBidComponents.trackObjects = 0;
  
  cQuoteQualifier.klass = rb_define_class_under(mQuickfix, "QuoteQualifier", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteQualifier, (void *) &cQuoteQualifier);
  rb_define_alloc_func(cQuoteQualifier.klass, _wrap_QuoteQualifier_allocate);
  rb_define_method(cQuoteQualifier.klass, "initialize", VALUEFUNC(_wrap_new_QuoteQualifier), -1);
  cQuoteQualifier.mark = 0;
  cQuoteQualifier.destroy = (void (*)(void *)) free_FIX_QuoteQualifier;
  cQuoteQualifier.trackObjects = 0;
  
  cScope.klass = rb_define_class_under(mQuickfix, "Scope", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Scope, (void *) &cScope);
  rb_define_alloc_func(cScope.klass, _wrap_Scope_allocate);
  rb_define_method(cScope.klass, "initialize", VALUEFUNC(_wrap_new_Scope), -1);
  cScope.mark = 0;
  cScope.destroy = (void (*)(void *)) free_FIX_Scope;
  cScope.trackObjects = 0;
  
  cNoSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSecurityAltID, (void *) &cNoSecurityAltID);
  rb_define_alloc_func(cNoSecurityAltID.klass, _wrap_NoSecurityAltID_allocate);
  rb_define_method(cNoSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoSecurityAltID), -1);
  cNoSecurityAltID.mark = 0;
  cNoSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoSecurityAltID;
  cNoSecurityAltID.trackObjects = 0;
  
  cRootPartySubID.klass = rb_define_class_under(mQuickfix, "RootPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartySubID, (void *) &cRootPartySubID);
  rb_define_alloc_func(cRootPartySubID.klass, _wrap_RootPartySubID_allocate);
  rb_define_method(cRootPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_RootPartySubID), -1);
  cRootPartySubID.mark = 0;
  cRootPartySubID.destroy = (void (*)(void *)) free_FIX_RootPartySubID;
  cRootPartySubID.trackObjects = 0;
  
  cDeliverToLocationID.klass = rb_define_class_under(mQuickfix, "DeliverToLocationID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeliverToLocationID, (void *) &cDeliverToLocationID);
  rb_define_alloc_func(cDeliverToLocationID.klass, _wrap_DeliverToLocationID_allocate);
  rb_define_method(cDeliverToLocationID.klass, "initialize", VALUEFUNC(_wrap_new_DeliverToLocationID), -1);
  cDeliverToLocationID.mark = 0;
  cDeliverToLocationID.destroy = (void (*)(void *)) free_FIX_DeliverToLocationID;
  cDeliverToLocationID.trackObjects = 0;
  
  cDeleteReason.klass = rb_define_class_under(mQuickfix, "DeleteReason", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeleteReason, (void *) &cDeleteReason);
  rb_define_alloc_func(cDeleteReason.klass, _wrap_DeleteReason_allocate);
  rb_define_method(cDeleteReason.klass, "initialize", VALUEFUNC(_wrap_new_DeleteReason), -1);
  cDeleteReason.mark = 0;
  cDeleteReason.destroy = (void (*)(void *)) free_FIX_DeleteReason;
  cDeleteReason.trackObjects = 0;
  
  cBidSpotRate.klass = rb_define_class_under(mQuickfix, "BidSpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidSpotRate, (void *) &cBidSpotRate);
  rb_define_alloc_func(cBidSpotRate.klass, _wrap_BidSpotRate_allocate);
  rb_define_method(cBidSpotRate.klass, "initialize", VALUEFUNC(_wrap_new_BidSpotRate), -1);
  cBidSpotRate.mark = 0;
  cBidSpotRate.destroy = (void (*)(void *)) free_FIX_BidSpotRate;
  cBidSpotRate.trackObjects = 0;
  
  cNested4PartyID.klass = rb_define_class_under(mQuickfix, "Nested4PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartyID, (void *) &cNested4PartyID);
  rb_define_alloc_func(cNested4PartyID.klass, _wrap_Nested4PartyID_allocate);
  rb_define_method(cNested4PartyID.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartyID), -1);
  cNested4PartyID.mark = 0;
  cNested4PartyID.destroy = (void (*)(void *)) free_FIX_Nested4PartyID;
  cNested4PartyID.trackObjects = 0;
  
  cInViewOfCommon.klass = rb_define_class_under(mQuickfix, "InViewOfCommon", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InViewOfCommon, (void *) &cInViewOfCommon);
  rb_define_alloc_func(cInViewOfCommon.klass, _wrap_InViewOfCommon_allocate);
  rb_define_method(cInViewOfCommon.klass, "initialize", VALUEFUNC(_wrap_new_InViewOfCommon), -1);
  cInViewOfCommon.mark = 0;
  cInViewOfCommon.destroy = (void (*)(void *)) free_FIX_InViewOfCommon;
  cInViewOfCommon.trackObjects = 0;
  
  cUnderlyingSettlPrice.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlPrice, (void *) &cUnderlyingSettlPrice);
  rb_define_alloc_func(cUnderlyingSettlPrice.klass, _wrap_UnderlyingSettlPrice_allocate);
  rb_define_method(cUnderlyingSettlPrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlPrice), -1);
  cUnderlyingSettlPrice.mark = 0;
  cUnderlyingSettlPrice.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlPrice;
  cUnderlyingSettlPrice.trackObjects = 0;
  
  cRegistRejReasonText.klass = rb_define_class_under(mQuickfix, "RegistRejReasonText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistRejReasonText, (void *) &cRegistRejReasonText);
  rb_define_alloc_func(cRegistRejReasonText.klass, _wrap_RegistRejReasonText_allocate);
  rb_define_method(cRegistRejReasonText.klass, "initialize", VALUEFUNC(_wrap_new_RegistRejReasonText), -1);
  cRegistRejReasonText.mark = 0;
  cRegistRejReasonText.destroy = (void (*)(void *)) free_FIX_RegistRejReasonText;
  cRegistRejReasonText.trackObjects = 0;
  
  cNoSides.klass = rb_define_class_under(mQuickfix, "NoSides", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSides, (void *) &cNoSides);
  rb_define_alloc_func(cNoSides.klass, _wrap_NoSides_allocate);
  rb_define_method(cNoSides.klass, "initialize", VALUEFUNC(_wrap_new_NoSides), -1);
  cNoSides.mark = 0;
  cNoSides.destroy = (void (*)(void *)) free_FIX_NoSides;
  cNoSides.trackObjects = 0;
  
  cLegAllocAccount.klass = rb_define_class_under(mQuickfix, "LegAllocAccount", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocAccount, (void *) &cLegAllocAccount);
  rb_define_alloc_func(cLegAllocAccount.klass, _wrap_LegAllocAccount_allocate);
  rb_define_method(cLegAllocAccount.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocAccount), -1);
  cLegAllocAccount.mark = 0;
  cLegAllocAccount.destroy = (void (*)(void *)) free_FIX_LegAllocAccount;
  cLegAllocAccount.trackObjects = 0;
  
  cNoRelationshipRiskWarningLevels.klass = rb_define_class_under(mQuickfix, "NoRelationshipRiskWarningLevels", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelationshipRiskWarningLevels, (void *) &cNoRelationshipRiskWarningLevels);
  rb_define_alloc_func(cNoRelationshipRiskWarningLevels.klass, _wrap_NoRelationshipRiskWarningLevels_allocate);
  rb_define_method(cNoRelationshipRiskWarningLevels.klass, "initialize", VALUEFUNC(_wrap_new_NoRelationshipRiskWarningLevels), -1);
  cNoRelationshipRiskWarningLevels.mark = 0;
  cNoRelationshipRiskWarningLevels.destroy = (void (*)(void *)) free_FIX_NoRelationshipRiskWarningLevels;
  cNoRelationshipRiskWarningLevels.trackObjects = 0;
  
  cRelationshipRiskProduct.klass = rb_define_class_under(mQuickfix, "RelationshipRiskProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskProduct, (void *) &cRelationshipRiskProduct);
  rb_define_alloc_func(cRelationshipRiskProduct.klass, _wrap_RelationshipRiskProduct_allocate);
  rb_define_method(cRelationshipRiskProduct.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskProduct), -1);
  cRelationshipRiskProduct.mark = 0;
  cRelationshipRiskProduct.destroy = (void (*)(void *)) free_FIX_RelationshipRiskProduct;
  cRelationshipRiskProduct.trackObjects = 0;
  
  cLegSecurityDesc.klass = rb_define_class_under(mQuickfix, "LegSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityDesc, (void *) &cLegSecurityDesc);
  rb_define_alloc_func(cLegSecurityDesc.klass, _wrap_LegSecurityDesc_allocate);
  rb_define_method(cLegSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityDesc), -1);
  cLegSecurityDesc.mark = 0;
  cLegSecurityDesc.destroy = (void (*)(void *)) free_FIX_LegSecurityDesc;
  cLegSecurityDesc.trackObjects = 0;
  
  cClOrdLinkID.klass = rb_define_class_under(mQuickfix, "ClOrdLinkID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClOrdLinkID, (void *) &cClOrdLinkID);
  rb_define_alloc_func(cClOrdLinkID.klass, _wrap_ClOrdLinkID_allocate);
  rb_define_method(cClOrdLinkID.klass, "initialize", VALUEFUNC(_wrap_new_ClOrdLinkID), -1);
  cClOrdLinkID.mark = 0;
  cClOrdLinkID.destroy = (void (*)(void *)) free_FIX_ClOrdLinkID;
  cClOrdLinkID.trackObjects = 0;
  
  cOrigSendingTime.klass = rb_define_class_under(mQuickfix, "OrigSendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigSendingTime, (void *) &cOrigSendingTime);
  rb_define_alloc_func(cOrigSendingTime.klass, _wrap_OrigSendingTime_allocate);
  rb_define_method(cOrigSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_OrigSendingTime), -1);
  cOrigSendingTime.mark = 0;
  cOrigSendingTime.destroy = (void (*)(void *)) free_FIX_OrigSendingTime;
  cOrigSendingTime.trackObjects = 0;
  
  cEncodedLegIssuerLen.klass = rb_define_class_under(mQuickfix, "EncodedLegIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedLegIssuerLen, (void *) &cEncodedLegIssuerLen);
  rb_define_alloc_func(cEncodedLegIssuerLen.klass, _wrap_EncodedLegIssuerLen_allocate);
  rb_define_method(cEncodedLegIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedLegIssuerLen), -1);
  cEncodedLegIssuerLen.mark = 0;
  cEncodedLegIssuerLen.destroy = (void (*)(void *)) free_FIX_EncodedLegIssuerLen;
  cEncodedLegIssuerLen.trackObjects = 0;
  
  cOrderID.klass = rb_define_class_under(mQuickfix, "OrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderID, (void *) &cOrderID);
  rb_define_alloc_func(cOrderID.klass, _wrap_OrderID_allocate);
  rb_define_method(cOrderID.klass, "initialize", VALUEFUNC(_wrap_new_OrderID), -1);
  cOrderID.mark = 0;
  cOrderID.destroy = (void (*)(void *)) free_FIX_OrderID;
  cOrderID.trackObjects = 0;
  
  cSecurityType.klass = rb_define_class_under(mQuickfix, "SecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityType, (void *) &cSecurityType);
  rb_define_alloc_func(cSecurityType.klass, _wrap_SecurityType_allocate);
  rb_define_method(cSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_SecurityType), -1);
  cSecurityType.mark = 0;
  cSecurityType.destroy = (void (*)(void *)) free_FIX_SecurityType;
  cSecurityType.trackObjects = 0;
  
  cRoundingDirection.klass = rb_define_class_under(mQuickfix, "RoundingDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoundingDirection, (void *) &cRoundingDirection);
  rb_define_alloc_func(cRoundingDirection.klass, _wrap_RoundingDirection_allocate);
  rb_define_method(cRoundingDirection.klass, "initialize", VALUEFUNC(_wrap_new_RoundingDirection), -1);
  cRoundingDirection.mark = 0;
  cRoundingDirection.destroy = (void (*)(void *)) free_FIX_RoundingDirection;
  cRoundingDirection.trackObjects = 0;
  
  cFillExecID.klass = rb_define_class_under(mQuickfix, "FillExecID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillExecID, (void *) &cFillExecID);
  rb_define_alloc_func(cFillExecID.klass, _wrap_FillExecID_allocate);
  rb_define_method(cFillExecID.klass, "initialize", VALUEFUNC(_wrap_new_FillExecID), -1);
  cFillExecID.mark = 0;
  cFillExecID.destroy = (void (*)(void *)) free_FIX_FillExecID;
  cFillExecID.trackObjects = 0;
  
  cNoEvents.klass = rb_define_class_under(mQuickfix, "NoEvents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoEvents, (void *) &cNoEvents);
  rb_define_alloc_func(cNoEvents.klass, _wrap_NoEvents_allocate);
  rb_define_method(cNoEvents.klass, "initialize", VALUEFUNC(_wrap_new_NoEvents), -1);
  cNoEvents.mark = 0;
  cNoEvents.destroy = (void (*)(void *)) free_FIX_NoEvents;
  cNoEvents.trackObjects = 0;
  
  cRoundLot.klass = rb_define_class_under(mQuickfix, "RoundLot", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoundLot, (void *) &cRoundLot);
  rb_define_alloc_func(cRoundLot.klass, _wrap_RoundLot_allocate);
  rb_define_method(cRoundLot.klass, "initialize", VALUEFUNC(_wrap_new_RoundLot), -1);
  cRoundLot.mark = 0;
  cRoundLot.destroy = (void (*)(void *)) free_FIX_RoundLot;
  cRoundLot.trackObjects = 0;
  
  cMDEntrySize.klass = rb_define_class_under(mQuickfix, "MDEntrySize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntrySize, (void *) &cMDEntrySize);
  rb_define_alloc_func(cMDEntrySize.klass, _wrap_MDEntrySize_allocate);
  rb_define_method(cMDEntrySize.klass, "initialize", VALUEFUNC(_wrap_new_MDEntrySize), -1);
  cMDEntrySize.mark = 0;
  cMDEntrySize.destroy = (void (*)(void *)) free_FIX_MDEntrySize;
  cMDEntrySize.trackObjects = 0;
  
  cEncodedIssuerLen.klass = rb_define_class_under(mQuickfix, "EncodedIssuerLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedIssuerLen, (void *) &cEncodedIssuerLen);
  rb_define_alloc_func(cEncodedIssuerLen.klass, _wrap_EncodedIssuerLen_allocate);
  rb_define_method(cEncodedIssuerLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedIssuerLen), -1);
  cEncodedIssuerLen.mark = 0;
  cEncodedIssuerLen.destroy = (void (*)(void *)) free_FIX_EncodedIssuerLen;
  cEncodedIssuerLen.trackObjects = 0;
  
  cDerivativePriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "DerivativePriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty, (void *) &cDerivativePriceUnitOfMeasureQty);
  rb_define_alloc_func(cDerivativePriceUnitOfMeasureQty.klass, _wrap_DerivativePriceUnitOfMeasureQty_allocate);
  rb_define_method(cDerivativePriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePriceUnitOfMeasureQty), -1);
  cDerivativePriceUnitOfMeasureQty.mark = 0;
  cDerivativePriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_DerivativePriceUnitOfMeasureQty;
  cDerivativePriceUnitOfMeasureQty.trackObjects = 0;
  
  cTimeUnit.klass = rb_define_class_under(mQuickfix, "TimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeUnit, (void *) &cTimeUnit);
  rb_define_alloc_func(cTimeUnit.klass, _wrap_TimeUnit_allocate);
  rb_define_method(cTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_TimeUnit), -1);
  cTimeUnit.mark = 0;
  cTimeUnit.destroy = (void (*)(void *)) free_FIX_TimeUnit;
  cTimeUnit.trackObjects = 0;
  
  cTotNoOrders.klass = rb_define_class_under(mQuickfix, "TotNoOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoOrders, (void *) &cTotNoOrders);
  rb_define_alloc_func(cTotNoOrders.klass, _wrap_TotNoOrders_allocate);
  rb_define_method(cTotNoOrders.klass, "initialize", VALUEFUNC(_wrap_new_TotNoOrders), -1);
  cTotNoOrders.mark = 0;
  cTotNoOrders.destroy = (void (*)(void *)) free_FIX_TotNoOrders;
  cTotNoOrders.trackObjects = 0;
  
  cPartyAltID.klass = rb_define_class_under(mQuickfix, "PartyAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyAltID, (void *) &cPartyAltID);
  rb_define_alloc_func(cPartyAltID.klass, _wrap_PartyAltID_allocate);
  rb_define_method(cPartyAltID.klass, "initialize", VALUEFUNC(_wrap_new_PartyAltID), -1);
  cPartyAltID.mark = 0;
  cPartyAltID.destroy = (void (*)(void *)) free_FIX_PartyAltID;
  cPartyAltID.trackObjects = 0;
  
  cLegSwapType.klass = rb_define_class_under(mQuickfix, "LegSwapType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSwapType, (void *) &cLegSwapType);
  rb_define_alloc_func(cLegSwapType.klass, _wrap_LegSwapType_allocate);
  rb_define_method(cLegSwapType.klass, "initialize", VALUEFUNC(_wrap_new_LegSwapType), -1);
  cLegSwapType.mark = 0;
  cLegSwapType.destroy = (void (*)(void *)) free_FIX_LegSwapType;
  cLegSwapType.trackObjects = 0;
  
  cIOITransType.klass = rb_define_class_under(mQuickfix, "IOITransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOITransType, (void *) &cIOITransType);
  rb_define_alloc_func(cIOITransType.klass, _wrap_IOITransType_allocate);
  rb_define_method(cIOITransType.klass, "initialize", VALUEFUNC(_wrap_new_IOITransType), -1);
  cIOITransType.mark = 0;
  cIOITransType.destroy = (void (*)(void *)) free_FIX_IOITransType;
  cIOITransType.trackObjects = 0;
  
  cRawDataLength.klass = rb_define_class_under(mQuickfix, "RawDataLength", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RawDataLength, (void *) &cRawDataLength);
  rb_define_alloc_func(cRawDataLength.klass, _wrap_RawDataLength_allocate);
  rb_define_method(cRawDataLength.klass, "initialize", VALUEFUNC(_wrap_new_RawDataLength), -1);
  cRawDataLength.mark = 0;
  cRawDataLength.destroy = (void (*)(void *)) free_FIX_RawDataLength;
  cRawDataLength.trackObjects = 0;
  
  cUnderlyingSecurityType.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityType, (void *) &cUnderlyingSecurityType);
  rb_define_alloc_func(cUnderlyingSecurityType.klass, _wrap_UnderlyingSecurityType_allocate);
  rb_define_method(cUnderlyingSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityType), -1);
  cUnderlyingSecurityType.mark = 0;
  cUnderlyingSecurityType.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityType;
  cUnderlyingSecurityType.trackObjects = 0;
  
  cUnderlyingLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID, (void *) &cUnderlyingLegSecurityAltID);
  rb_define_alloc_func(cUnderlyingLegSecurityAltID.klass, _wrap_UnderlyingLegSecurityAltID_allocate);
  rb_define_method(cUnderlyingLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityAltID), -1);
  cUnderlyingLegSecurityAltID.mark = 0;
  cUnderlyingLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityAltID;
  cUnderlyingLegSecurityAltID.trackObjects = 0;
  
  cSecurityReportID.klass = rb_define_class_under(mQuickfix, "SecurityReportID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityReportID, (void *) &cSecurityReportID);
  rb_define_alloc_func(cSecurityReportID.klass, _wrap_SecurityReportID_allocate);
  rb_define_method(cSecurityReportID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityReportID), -1);
  cSecurityReportID.mark = 0;
  cSecurityReportID.destroy = (void (*)(void *)) free_FIX_SecurityReportID;
  cSecurityReportID.trackObjects = 0;
  
  cTotNumReports.klass = rb_define_class_under(mQuickfix, "TotNumReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNumReports, (void *) &cTotNumReports);
  rb_define_alloc_func(cTotNumReports.klass, _wrap_TotNumReports_allocate);
  rb_define_method(cTotNumReports.klass, "initialize", VALUEFUNC(_wrap_new_TotNumReports), -1);
  cTotNumReports.mark = 0;
  cTotNumReports.destroy = (void (*)(void *)) free_FIX_TotNumReports;
  cTotNumReports.trackObjects = 0;
  
  cTotalNumPosReports.klass = rb_define_class_under(mQuickfix, "TotalNumPosReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNumPosReports, (void *) &cTotalNumPosReports);
  rb_define_alloc_func(cTotalNumPosReports.klass, _wrap_TotalNumPosReports_allocate);
  rb_define_method(cTotalNumPosReports.klass, "initialize", VALUEFUNC(_wrap_new_TotalNumPosReports), -1);
  cTotalNumPosReports.mark = 0;
  cTotalNumPosReports.destroy = (void (*)(void *)) free_FIX_TotalNumPosReports;
  cTotalNumPosReports.trackObjects = 0;
  
  cSecurityReqID.klass = rb_define_class_under(mQuickfix, "SecurityReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityReqID, (void *) &cSecurityReqID);
  rb_define_alloc_func(cSecurityReqID.klass, _wrap_SecurityReqID_allocate);
  rb_define_method(cSecurityReqID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityReqID), -1);
  cSecurityReqID.mark = 0;
  cSecurityReqID.destroy = (void (*)(void *)) free_FIX_SecurityReqID;
  cSecurityReqID.trackObjects = 0;
  
  cPosReqResult.klass = rb_define_class_under(mQuickfix, "PosReqResult", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqResult, (void *) &cPosReqResult);
  rb_define_alloc_func(cPosReqResult.klass, _wrap_PosReqResult_allocate);
  rb_define_method(cPosReqResult.klass, "initialize", VALUEFUNC(_wrap_new_PosReqResult), -1);
  cPosReqResult.mark = 0;
  cPosReqResult.destroy = (void (*)(void *)) free_FIX_PosReqResult;
  cPosReqResult.trackObjects = 0;
  
  cLegOfferForwardPoints.klass = rb_define_class_under(mQuickfix, "LegOfferForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOfferForwardPoints, (void *) &cLegOfferForwardPoints);
  rb_define_alloc_func(cLegOfferForwardPoints.klass, _wrap_LegOfferForwardPoints_allocate);
  rb_define_method(cLegOfferForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LegOfferForwardPoints), -1);
  cLegOfferForwardPoints.mark = 0;
  cLegOfferForwardPoints.destroy = (void (*)(void *)) free_FIX_LegOfferForwardPoints;
  cLegOfferForwardPoints.trackObjects = 0;
  
  cAllowableOneSidednessCurr.klass = rb_define_class_under(mQuickfix, "AllowableOneSidednessCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllowableOneSidednessCurr, (void *) &cAllowableOneSidednessCurr);
  rb_define_alloc_func(cAllowableOneSidednessCurr.klass, _wrap_AllowableOneSidednessCurr_allocate);
  rb_define_method(cAllowableOneSidednessCurr.klass, "initialize", VALUEFUNC(_wrap_new_AllowableOneSidednessCurr), -1);
  cAllowableOneSidednessCurr.mark = 0;
  cAllowableOneSidednessCurr.destroy = (void (*)(void *)) free_FIX_AllowableOneSidednessCurr;
  cAllowableOneSidednessCurr.trackObjects = 0;
  
  cAffectedOrderID.klass = rb_define_class_under(mQuickfix, "AffectedOrderID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AffectedOrderID, (void *) &cAffectedOrderID);
  rb_define_alloc_func(cAffectedOrderID.klass, _wrap_AffectedOrderID_allocate);
  rb_define_method(cAffectedOrderID.klass, "initialize", VALUEFUNC(_wrap_new_AffectedOrderID), -1);
  cAffectedOrderID.mark = 0;
  cAffectedOrderID.destroy = (void (*)(void *)) free_FIX_AffectedOrderID;
  cAffectedOrderID.trackObjects = 0;
  
  cUnderlyingCountryOfIssue.klass = rb_define_class_under(mQuickfix, "UnderlyingCountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCountryOfIssue, (void *) &cUnderlyingCountryOfIssue);
  rb_define_alloc_func(cUnderlyingCountryOfIssue.klass, _wrap_UnderlyingCountryOfIssue_allocate);
  rb_define_method(cUnderlyingCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCountryOfIssue), -1);
  cUnderlyingCountryOfIssue.mark = 0;
  cUnderlyingCountryOfIssue.destroy = (void (*)(void *)) free_FIX_UnderlyingCountryOfIssue;
  cUnderlyingCountryOfIssue.trackObjects = 0;
  
  cUnderlyingRepurchaseRate.klass = rb_define_class_under(mQuickfix, "UnderlyingRepurchaseRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRepurchaseRate, (void *) &cUnderlyingRepurchaseRate);
  rb_define_alloc_func(cUnderlyingRepurchaseRate.klass, _wrap_UnderlyingRepurchaseRate_allocate);
  rb_define_method(cUnderlyingRepurchaseRate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRepurchaseRate), -1);
  cUnderlyingRepurchaseRate.mark = 0;
  cUnderlyingRepurchaseRate.destroy = (void (*)(void *)) free_FIX_UnderlyingRepurchaseRate;
  cUnderlyingRepurchaseRate.trackObjects = 0;
  
  cLastMsgSeqNumProcessed.klass = rb_define_class_under(mQuickfix, "LastMsgSeqNumProcessed", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastMsgSeqNumProcessed, (void *) &cLastMsgSeqNumProcessed);
  rb_define_alloc_func(cLastMsgSeqNumProcessed.klass, _wrap_LastMsgSeqNumProcessed_allocate);
  rb_define_method(cLastMsgSeqNumProcessed.klass, "initialize", VALUEFUNC(_wrap_new_LastMsgSeqNumProcessed), -1);
  cLastMsgSeqNumProcessed.mark = 0;
  cLastMsgSeqNumProcessed.destroy = (void (*)(void *)) free_FIX_LastMsgSeqNumProcessed;
  cLastMsgSeqNumProcessed.trackObjects = 0;
  
  cUnderlyingCFICode.klass = rb_define_class_under(mQuickfix, "UnderlyingCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCFICode, (void *) &cUnderlyingCFICode);
  rb_define_alloc_func(cUnderlyingCFICode.klass, _wrap_UnderlyingCFICode_allocate);
  rb_define_method(cUnderlyingCFICode.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCFICode), -1);
  cUnderlyingCFICode.mark = 0;
  cUnderlyingCFICode.destroy = (void (*)(void *)) free_FIX_UnderlyingCFICode;
  cUnderlyingCFICode.trackObjects = 0;
  
  cDerivativeOptAttribute.klass = rb_define_class_under(mQuickfix, "DerivativeOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeOptAttribute, (void *) &cDerivativeOptAttribute);
  rb_define_alloc_func(cDerivativeOptAttribute.klass, _wrap_DerivativeOptAttribute_allocate);
  rb_define_method(cDerivativeOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeOptAttribute), -1);
  cDerivativeOptAttribute.mark = 0;
  cDerivativeOptAttribute.destroy = (void (*)(void *)) free_FIX_DerivativeOptAttribute;
  cDerivativeOptAttribute.trackObjects = 0;
  
  cPegSecurityID.klass = rb_define_class_under(mQuickfix, "PegSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSecurityID, (void *) &cPegSecurityID);
  rb_define_alloc_func(cPegSecurityID.klass, _wrap_PegSecurityID_allocate);
  rb_define_method(cPegSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_PegSecurityID), -1);
  cPegSecurityID.mark = 0;
  cPegSecurityID.destroy = (void (*)(void *)) free_FIX_PegSecurityID;
  cPegSecurityID.trackObjects = 0;
  
  cHostCrossID.klass = rb_define_class_under(mQuickfix, "HostCrossID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HostCrossID, (void *) &cHostCrossID);
  rb_define_alloc_func(cHostCrossID.klass, _wrap_HostCrossID_allocate);
  rb_define_method(cHostCrossID.klass, "initialize", VALUEFUNC(_wrap_new_HostCrossID), -1);
  cHostCrossID.mark = 0;
  cHostCrossID.destroy = (void (*)(void *)) free_FIX_HostCrossID;
  cHostCrossID.trackObjects = 0;
  
  cExecInstValue.klass = rb_define_class_under(mQuickfix, "ExecInstValue", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecInstValue, (void *) &cExecInstValue);
  rb_define_alloc_func(cExecInstValue.klass, _wrap_ExecInstValue_allocate);
  rb_define_method(cExecInstValue.klass, "initialize", VALUEFUNC(_wrap_new_ExecInstValue), -1);
  cExecInstValue.mark = 0;
  cExecInstValue.destroy = (void (*)(void *)) free_FIX_ExecInstValue;
  cExecInstValue.trackObjects = 0;
  
  cDerivativeOptPayAmount.klass = rb_define_class_under(mQuickfix, "DerivativeOptPayAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeOptPayAmount, (void *) &cDerivativeOptPayAmount);
  rb_define_alloc_func(cDerivativeOptPayAmount.klass, _wrap_DerivativeOptPayAmount_allocate);
  rb_define_method(cDerivativeOptPayAmount.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeOptPayAmount), -1);
  cDerivativeOptPayAmount.mark = 0;
  cDerivativeOptPayAmount.destroy = (void (*)(void *)) free_FIX_DerivativeOptPayAmount;
  cDerivativeOptPayAmount.trackObjects = 0;
  
  cUnderlyingCouponRate.klass = rb_define_class_under(mQuickfix, "UnderlyingCouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCouponRate, (void *) &cUnderlyingCouponRate);
  rb_define_alloc_func(cUnderlyingCouponRate.klass, _wrap_UnderlyingCouponRate_allocate);
  rb_define_method(cUnderlyingCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCouponRate), -1);
  cUnderlyingCouponRate.mark = 0;
  cUnderlyingCouponRate.destroy = (void (*)(void *)) free_FIX_UnderlyingCouponRate;
  cUnderlyingCouponRate.trackObjects = 0;
  
  cSettlInstMode.klass = rb_define_class_under(mQuickfix, "SettlInstMode", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstMode, (void *) &cSettlInstMode);
  rb_define_alloc_func(cSettlInstMode.klass, _wrap_SettlInstMode_allocate);
  rb_define_method(cSettlInstMode.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstMode), -1);
  cSettlInstMode.mark = 0;
  cSettlInstMode.destroy = (void (*)(void *)) free_FIX_SettlInstMode;
  cSettlInstMode.trackObjects = 0;
  
  cSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "SecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityAltIDSource, (void *) &cSecurityAltIDSource);
  rb_define_alloc_func(cSecurityAltIDSource.klass, _wrap_SecurityAltIDSource_allocate);
  rb_define_method(cSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_SecurityAltIDSource), -1);
  cSecurityAltIDSource.mark = 0;
  cSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_SecurityAltIDSource;
  cSecurityAltIDSource.trackObjects = 0;
  
  cPreviouslyReported.klass = rb_define_class_under(mQuickfix, "PreviouslyReported", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PreviouslyReported, (void *) &cPreviouslyReported);
  rb_define_alloc_func(cPreviouslyReported.klass, _wrap_PreviouslyReported_allocate);
  rb_define_method(cPreviouslyReported.klass, "initialize", VALUEFUNC(_wrap_new_PreviouslyReported), -1);
  cPreviouslyReported.mark = 0;
  cPreviouslyReported.destroy = (void (*)(void *)) free_FIX_PreviouslyReported;
  cPreviouslyReported.trackObjects = 0;
  
  cContextPartyIDSource.klass = rb_define_class_under(mQuickfix, "ContextPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContextPartyIDSource, (void *) &cContextPartyIDSource);
  rb_define_alloc_func(cContextPartyIDSource.klass, _wrap_ContextPartyIDSource_allocate);
  rb_define_method(cContextPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_ContextPartyIDSource), -1);
  cContextPartyIDSource.mark = 0;
  cContextPartyIDSource.destroy = (void (*)(void *)) free_FIX_ContextPartyIDSource;
  cContextPartyIDSource.trackObjects = 0;
  
  cRptSys.klass = rb_define_class_under(mQuickfix, "RptSys", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RptSys, (void *) &cRptSys);
  rb_define_alloc_func(cRptSys.klass, _wrap_RptSys_allocate);
  rb_define_method(cRptSys.klass, "initialize", VALUEFUNC(_wrap_new_RptSys), -1);
  cRptSys.mark = 0;
  cRptSys.destroy = (void (*)(void *)) free_FIX_RptSys;
  cRptSys.trackObjects = 0;
  
  cNoNested2PartySubIDs.klass = rb_define_class_under(mQuickfix, "NoNested2PartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested2PartySubIDs, (void *) &cNoNested2PartySubIDs);
  rb_define_alloc_func(cNoNested2PartySubIDs.klass, _wrap_NoNested2PartySubIDs_allocate);
  rb_define_method(cNoNested2PartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested2PartySubIDs), -1);
  cNoNested2PartySubIDs.mark = 0;
  cNoNested2PartySubIDs.destroy = (void (*)(void *)) free_FIX_NoNested2PartySubIDs;
  cNoNested2PartySubIDs.trackObjects = 0;
  
  cRefAllocID.klass = rb_define_class_under(mQuickfix, "RefAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefAllocID, (void *) &cRefAllocID);
  rb_define_alloc_func(cRefAllocID.klass, _wrap_RefAllocID_allocate);
  rb_define_method(cRefAllocID.klass, "initialize", VALUEFUNC(_wrap_new_RefAllocID), -1);
  cRefAllocID.mark = 0;
  cRefAllocID.destroy = (void (*)(void *)) free_FIX_RefAllocID;
  cRefAllocID.trackObjects = 0;
  
  cDefOfferSize.klass = rb_define_class_under(mQuickfix, "DefOfferSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefOfferSize, (void *) &cDefOfferSize);
  rb_define_alloc_func(cDefOfferSize.klass, _wrap_DefOfferSize_allocate);
  rb_define_method(cDefOfferSize.klass, "initialize", VALUEFUNC(_wrap_new_DefOfferSize), -1);
  cDefOfferSize.mark = 0;
  cDefOfferSize.destroy = (void (*)(void *)) free_FIX_DefOfferSize;
  cDefOfferSize.trackObjects = 0;
  
  cProductComplex.klass = rb_define_class_under(mQuickfix, "ProductComplex", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProductComplex, (void *) &cProductComplex);
  rb_define_alloc_func(cProductComplex.klass, _wrap_ProductComplex_allocate);
  rb_define_method(cProductComplex.klass, "initialize", VALUEFUNC(_wrap_new_ProductComplex), -1);
  cProductComplex.mark = 0;
  cProductComplex.destroy = (void (*)(void *)) free_FIX_ProductComplex;
  cProductComplex.trackObjects = 0;
  
  cCustOrderHandlingInst.klass = rb_define_class_under(mQuickfix, "CustOrderHandlingInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustOrderHandlingInst, (void *) &cCustOrderHandlingInst);
  rb_define_alloc_func(cCustOrderHandlingInst.klass, _wrap_CustOrderHandlingInst_allocate);
  rb_define_method(cCustOrderHandlingInst.klass, "initialize", VALUEFUNC(_wrap_new_CustOrderHandlingInst), -1);
  cCustOrderHandlingInst.mark = 0;
  cCustOrderHandlingInst.destroy = (void (*)(void *)) free_FIX_CustOrderHandlingInst;
  cCustOrderHandlingInst.trackObjects = 0;
  
  cMDPriceLevel.klass = rb_define_class_under(mQuickfix, "MDPriceLevel", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDPriceLevel, (void *) &cMDPriceLevel);
  rb_define_alloc_func(cMDPriceLevel.klass, _wrap_MDPriceLevel_allocate);
  rb_define_method(cMDPriceLevel.klass, "initialize", VALUEFUNC(_wrap_new_MDPriceLevel), -1);
  cMDPriceLevel.mark = 0;
  cMDPriceLevel.destroy = (void (*)(void *)) free_FIX_MDPriceLevel;
  cMDPriceLevel.trackObjects = 0;
  
  cLegOptionRatio.klass = rb_define_class_under(mQuickfix, "LegOptionRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOptionRatio, (void *) &cLegOptionRatio);
  rb_define_alloc_func(cLegOptionRatio.klass, _wrap_LegOptionRatio_allocate);
  rb_define_method(cLegOptionRatio.klass, "initialize", VALUEFUNC(_wrap_new_LegOptionRatio), -1);
  cLegOptionRatio.mark = 0;
  cLegOptionRatio.destroy = (void (*)(void *)) free_FIX_LegOptionRatio;
  cLegOptionRatio.trackObjects = 0;
  
  cSecurityStatus.klass = rb_define_class_under(mQuickfix, "SecurityStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityStatus, (void *) &cSecurityStatus);
  rb_define_alloc_func(cSecurityStatus.klass, _wrap_SecurityStatus_allocate);
  rb_define_method(cSecurityStatus.klass, "initialize", VALUEFUNC(_wrap_new_SecurityStatus), -1);
  cSecurityStatus.mark = 0;
  cSecurityStatus.destroy = (void (*)(void *)) free_FIX_SecurityStatus;
  cSecurityStatus.trackObjects = 0;
  
  cLegRefID.klass = rb_define_class_under(mQuickfix, "LegRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRefID, (void *) &cLegRefID);
  rb_define_alloc_func(cLegRefID.klass, _wrap_LegRefID_allocate);
  rb_define_method(cLegRefID.klass, "initialize", VALUEFUNC(_wrap_new_LegRefID), -1);
  cLegRefID.mark = 0;
  cLegRefID.destroy = (void (*)(void *)) free_FIX_LegRefID;
  cLegRefID.trackObjects = 0;
  
  cDividendYield.klass = rb_define_class_under(mQuickfix, "DividendYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DividendYield, (void *) &cDividendYield);
  rb_define_alloc_func(cDividendYield.klass, _wrap_DividendYield_allocate);
  rb_define_method(cDividendYield.klass, "initialize", VALUEFUNC(_wrap_new_DividendYield), -1);
  cDividendYield.mark = 0;
  cDividendYield.destroy = (void (*)(void *)) free_FIX_DividendYield;
  cDividendYield.trackObjects = 0;
  
  cDerivativeInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType, (void *) &cDerivativeInstrumentPartySubIDType);
  rb_define_alloc_func(cDerivativeInstrumentPartySubIDType.klass, _wrap_DerivativeInstrumentPartySubIDType_allocate);
  rb_define_method(cDerivativeInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartySubIDType), -1);
  cDerivativeInstrumentPartySubIDType.mark = 0;
  cDerivativeInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartySubIDType;
  cDerivativeInstrumentPartySubIDType.trackObjects = 0;
  
  cEndStrikePxRange.klass = rb_define_class_under(mQuickfix, "EndStrikePxRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndStrikePxRange, (void *) &cEndStrikePxRange);
  rb_define_alloc_func(cEndStrikePxRange.klass, _wrap_EndStrikePxRange_allocate);
  rb_define_method(cEndStrikePxRange.klass, "initialize", VALUEFUNC(_wrap_new_EndStrikePxRange), -1);
  cEndStrikePxRange.mark = 0;
  cEndStrikePxRange.destroy = (void (*)(void *)) free_FIX_EndStrikePxRange;
  cEndStrikePxRange.trackObjects = 0;
  
  cDisplayQty.klass = rb_define_class_under(mQuickfix, "DisplayQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayQty, (void *) &cDisplayQty);
  rb_define_alloc_func(cDisplayQty.klass, _wrap_DisplayQty_allocate);
  rb_define_method(cDisplayQty.klass, "initialize", VALUEFUNC(_wrap_new_DisplayQty), -1);
  cDisplayQty.mark = 0;
  cDisplayQty.destroy = (void (*)(void *)) free_FIX_DisplayQty;
  cDisplayQty.trackObjects = 0;
  
  cLegSecuritySubType.klass = rb_define_class_under(mQuickfix, "LegSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecuritySubType, (void *) &cLegSecuritySubType);
  rb_define_alloc_func(cLegSecuritySubType.klass, _wrap_LegSecuritySubType_allocate);
  rb_define_method(cLegSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_LegSecuritySubType), -1);
  cLegSecuritySubType.mark = 0;
  cLegSecuritySubType.destroy = (void (*)(void *)) free_FIX_LegSecuritySubType;
  cLegSecuritySubType.trackObjects = 0;
  
  cProcessCode.klass = rb_define_class_under(mQuickfix, "ProcessCode", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ProcessCode, (void *) &cProcessCode);
  rb_define_alloc_func(cProcessCode.klass, _wrap_ProcessCode_allocate);
  rb_define_method(cProcessCode.klass, "initialize", VALUEFUNC(_wrap_new_ProcessCode), -1);
  cProcessCode.mark = 0;
  cProcessCode.destroy = (void (*)(void *)) free_FIX_ProcessCode;
  cProcessCode.trackObjects = 0;
  
  cExecInst.klass = rb_define_class_under(mQuickfix, "ExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecInst, (void *) &cExecInst);
  rb_define_alloc_func(cExecInst.klass, _wrap_ExecInst_allocate);
  rb_define_method(cExecInst.klass, "initialize", VALUEFUNC(_wrap_new_ExecInst), -1);
  cExecInst.mark = 0;
  cExecInst.destroy = (void (*)(void *)) free_FIX_ExecInst;
  cExecInst.trackObjects = 0;
  
  cTradSesEndTime.klass = rb_define_class_under(mQuickfix, "TradSesEndTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesEndTime, (void *) &cTradSesEndTime);
  rb_define_alloc_func(cTradSesEndTime.klass, _wrap_TradSesEndTime_allocate);
  rb_define_method(cTradSesEndTime.klass, "initialize", VALUEFUNC(_wrap_new_TradSesEndTime), -1);
  cTradSesEndTime.mark = 0;
  cTradSesEndTime.destroy = (void (*)(void *)) free_FIX_TradSesEndTime;
  cTradSesEndTime.trackObjects = 0;
  
  cOrigTime.klass = rb_define_class_under(mQuickfix, "OrigTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTime, (void *) &cOrigTime);
  rb_define_alloc_func(cOrigTime.klass, _wrap_OrigTime_allocate);
  rb_define_method(cOrigTime.klass, "initialize", VALUEFUNC(_wrap_new_OrigTime), -1);
  cOrigTime.mark = 0;
  cOrigTime.destroy = (void (*)(void *)) free_FIX_OrigTime;
  cOrigTime.trackObjects = 0;
  
  cExecValuationPoint.klass = rb_define_class_under(mQuickfix, "ExecValuationPoint", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecValuationPoint, (void *) &cExecValuationPoint);
  rb_define_alloc_func(cExecValuationPoint.klass, _wrap_ExecValuationPoint_allocate);
  rb_define_method(cExecValuationPoint.klass, "initialize", VALUEFUNC(_wrap_new_ExecValuationPoint), -1);
  cExecValuationPoint.mark = 0;
  cExecValuationPoint.destroy = (void (*)(void *)) free_FIX_ExecValuationPoint;
  cExecValuationPoint.trackObjects = 0;
  
  cExecType.klass = rb_define_class_under(mQuickfix, "ExecType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecType, (void *) &cExecType);
  rb_define_alloc_func(cExecType.klass, _wrap_ExecType_allocate);
  rb_define_method(cExecType.klass, "initialize", VALUEFUNC(_wrap_new_ExecType), -1);
  cExecType.mark = 0;
  cExecType.destroy = (void (*)(void *)) free_FIX_ExecType;
  cExecType.trackObjects = 0;
  
  cNoRelatedContextPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoRelatedContextPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedContextPartySubIDs, (void *) &cNoRelatedContextPartySubIDs);
  rb_define_alloc_func(cNoRelatedContextPartySubIDs.klass, _wrap_NoRelatedContextPartySubIDs_allocate);
  rb_define_method(cNoRelatedContextPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedContextPartySubIDs), -1);
  cNoRelatedContextPartySubIDs.mark = 0;
  cNoRelatedContextPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoRelatedContextPartySubIDs;
  cNoRelatedContextPartySubIDs.trackObjects = 0;
  
  cNested4PartyRole.klass = rb_define_class_under(mQuickfix, "Nested4PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartyRole, (void *) &cNested4PartyRole);
  rb_define_alloc_func(cNested4PartyRole.klass, _wrap_Nested4PartyRole_allocate);
  rb_define_method(cNested4PartyRole.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartyRole), -1);
  cNested4PartyRole.mark = 0;
  cNested4PartyRole.destroy = (void (*)(void *)) free_FIX_Nested4PartyRole;
  cNested4PartyRole.trackObjects = 0;
  
  cMultilegModel.klass = rb_define_class_under(mQuickfix, "MultilegModel", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MultilegModel, (void *) &cMultilegModel);
  rb_define_alloc_func(cMultilegModel.klass, _wrap_MultilegModel_allocate);
  rb_define_method(cMultilegModel.klass, "initialize", VALUEFUNC(_wrap_new_MultilegModel), -1);
  cMultilegModel.mark = 0;
  cMultilegModel.destroy = (void (*)(void *)) free_FIX_MultilegModel;
  cMultilegModel.trackObjects = 0;
  
  cSecurityGroup.klass = rb_define_class_under(mQuickfix, "SecurityGroup", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityGroup, (void *) &cSecurityGroup);
  rb_define_alloc_func(cSecurityGroup.klass, _wrap_SecurityGroup_allocate);
  rb_define_method(cSecurityGroup.klass, "initialize", VALUEFUNC(_wrap_new_SecurityGroup), -1);
  cSecurityGroup.mark = 0;
  cSecurityGroup.destroy = (void (*)(void *)) free_FIX_SecurityGroup;
  cSecurityGroup.trackObjects = 0;
  
  cEventType.klass = rb_define_class_under(mQuickfix, "EventType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventType, (void *) &cEventType);
  rb_define_alloc_func(cEventType.klass, _wrap_EventType_allocate);
  rb_define_method(cEventType.klass, "initialize", VALUEFUNC(_wrap_new_EventType), -1);
  cEventType.mark = 0;
  cEventType.destroy = (void (*)(void *)) free_FIX_EventType;
  cEventType.trackObjects = 0;
  
  cTradeAllocIndicator.klass = rb_define_class_under(mQuickfix, "TradeAllocIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeAllocIndicator, (void *) &cTradeAllocIndicator);
  rb_define_alloc_func(cTradeAllocIndicator.klass, _wrap_TradeAllocIndicator_allocate);
  rb_define_method(cTradeAllocIndicator.klass, "initialize", VALUEFUNC(_wrap_new_TradeAllocIndicator), -1);
  cTradeAllocIndicator.mark = 0;
  cTradeAllocIndicator.destroy = (void (*)(void *)) free_FIX_TradeAllocIndicator;
  cTradeAllocIndicator.trackObjects = 0;
  
  cYieldCalcDate.klass = rb_define_class_under(mQuickfix, "YieldCalcDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldCalcDate, (void *) &cYieldCalcDate);
  rb_define_alloc_func(cYieldCalcDate.klass, _wrap_YieldCalcDate_allocate);
  rb_define_method(cYieldCalcDate.klass, "initialize", VALUEFUNC(_wrap_new_YieldCalcDate), -1);
  cYieldCalcDate.mark = 0;
  cYieldCalcDate.destroy = (void (*)(void *)) free_FIX_YieldCalcDate;
  cYieldCalcDate.trackObjects = 0;
  
  cValueOfFutures.klass = rb_define_class_under(mQuickfix, "ValueOfFutures", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ValueOfFutures, (void *) &cValueOfFutures);
  rb_define_alloc_func(cValueOfFutures.klass, _wrap_ValueOfFutures_allocate);
  rb_define_method(cValueOfFutures.klass, "initialize", VALUEFUNC(_wrap_new_ValueOfFutures), -1);
  cValueOfFutures.mark = 0;
  cValueOfFutures.destroy = (void (*)(void *)) free_FIX_ValueOfFutures;
  cValueOfFutures.trackObjects = 0;
  
  cLegSide.klass = rb_define_class_under(mQuickfix, "LegSide", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSide, (void *) &cLegSide);
  rb_define_alloc_func(cLegSide.klass, _wrap_LegSide_allocate);
  rb_define_method(cLegSide.klass, "initialize", VALUEFUNC(_wrap_new_LegSide), -1);
  cLegSide.mark = 0;
  cLegSide.destroy = (void (*)(void *)) free_FIX_LegSide;
  cLegSide.trackObjects = 0;
  
  cUserStatus.klass = rb_define_class_under(mQuickfix, "UserStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UserStatus, (void *) &cUserStatus);
  rb_define_alloc_func(cUserStatus.klass, _wrap_UserStatus_allocate);
  rb_define_method(cUserStatus.klass, "initialize", VALUEFUNC(_wrap_new_UserStatus), -1);
  cUserStatus.mark = 0;
  cUserStatus.destroy = (void (*)(void *)) free_FIX_UserStatus;
  cUserStatus.trackObjects = 0;
  
  cSideValue1.klass = rb_define_class_under(mQuickfix, "SideValue1", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideValue1, (void *) &cSideValue1);
  rb_define_alloc_func(cSideValue1.klass, _wrap_SideValue1_allocate);
  rb_define_method(cSideValue1.klass, "initialize", VALUEFUNC(_wrap_new_SideValue1), -1);
  cSideValue1.mark = 0;
  cSideValue1.destroy = (void (*)(void *)) free_FIX_SideValue1;
  cSideValue1.trackObjects = 0;
  
  cCxlQty.klass = rb_define_class_under(mQuickfix, "CxlQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlQty, (void *) &cCxlQty);
  rb_define_alloc_func(cCxlQty.klass, _wrap_CxlQty_allocate);
  rb_define_method(cCxlQty.klass, "initialize", VALUEFUNC(_wrap_new_CxlQty), -1);
  cCxlQty.mark = 0;
  cCxlQty.destroy = (void (*)(void *)) free_FIX_CxlQty;
  cCxlQty.trackObjects = 0;
  
  cSecurityResponseID.klass = rb_define_class_under(mQuickfix, "SecurityResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityResponseID, (void *) &cSecurityResponseID);
  rb_define_alloc_func(cSecurityResponseID.klass, _wrap_SecurityResponseID_allocate);
  rb_define_method(cSecurityResponseID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityResponseID), -1);
  cSecurityResponseID.mark = 0;
  cSecurityResponseID.destroy = (void (*)(void *)) free_FIX_SecurityResponseID;
  cSecurityResponseID.trackObjects = 0;
  
  cInstrRegistry.klass = rb_define_class_under(mQuickfix, "InstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrRegistry, (void *) &cInstrRegistry);
  rb_define_alloc_func(cInstrRegistry.klass, _wrap_InstrRegistry_allocate);
  rb_define_method(cInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_InstrRegistry), -1);
  cInstrRegistry.mark = 0;
  cInstrRegistry.destroy = (void (*)(void *)) free_FIX_InstrRegistry;
  cInstrRegistry.trackObjects = 0;
  
  cStreamAsgnRptID.klass = rb_define_class_under(mQuickfix, "StreamAsgnRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnRptID, (void *) &cStreamAsgnRptID);
  rb_define_alloc_func(cStreamAsgnRptID.klass, _wrap_StreamAsgnRptID_allocate);
  rb_define_method(cStreamAsgnRptID.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnRptID), -1);
  cStreamAsgnRptID.mark = 0;
  cStreamAsgnRptID.destroy = (void (*)(void *)) free_FIX_StreamAsgnRptID;
  cStreamAsgnRptID.trackObjects = 0;
  
  cOrderDelayUnit.klass = rb_define_class_under(mQuickfix, "OrderDelayUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderDelayUnit, (void *) &cOrderDelayUnit);
  rb_define_alloc_func(cOrderDelayUnit.klass, _wrap_OrderDelayUnit_allocate);
  rb_define_method(cOrderDelayUnit.klass, "initialize", VALUEFUNC(_wrap_new_OrderDelayUnit), -1);
  cOrderDelayUnit.mark = 0;
  cOrderDelayUnit.destroy = (void (*)(void *)) free_FIX_OrderDelayUnit;
  cOrderDelayUnit.trackObjects = 0;
  
  cLegCurrencyRatio.klass = rb_define_class_under(mQuickfix, "LegCurrencyRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCurrencyRatio, (void *) &cLegCurrencyRatio);
  rb_define_alloc_func(cLegCurrencyRatio.klass, _wrap_LegCurrencyRatio_allocate);
  rb_define_method(cLegCurrencyRatio.klass, "initialize", VALUEFUNC(_wrap_new_LegCurrencyRatio), -1);
  cLegCurrencyRatio.mark = 0;
  cLegCurrencyRatio.destroy = (void (*)(void *)) free_FIX_LegCurrencyRatio;
  cLegCurrencyRatio.trackObjects = 0;
  
  cEndTickPriceRange.klass = rb_define_class_under(mQuickfix, "EndTickPriceRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndTickPriceRange, (void *) &cEndTickPriceRange);
  rb_define_alloc_func(cEndTickPriceRange.klass, _wrap_EndTickPriceRange_allocate);
  rb_define_method(cEndTickPriceRange.klass, "initialize", VALUEFUNC(_wrap_new_EndTickPriceRange), -1);
  cEndTickPriceRange.mark = 0;
  cEndTickPriceRange.destroy = (void (*)(void *)) free_FIX_EndTickPriceRange;
  cEndTickPriceRange.trackObjects = 0;
  
  cCollReqID.klass = rb_define_class_under(mQuickfix, "CollReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollReqID, (void *) &cCollReqID);
  rb_define_alloc_func(cCollReqID.klass, _wrap_CollReqID_allocate);
  rb_define_method(cCollReqID.klass, "initialize", VALUEFUNC(_wrap_new_CollReqID), -1);
  cCollReqID.mark = 0;
  cCollReqID.destroy = (void (*)(void *)) free_FIX_CollReqID;
  cCollReqID.trackObjects = 0;
  
  cLegPool.klass = rb_define_class_under(mQuickfix, "LegPool", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPool, (void *) &cLegPool);
  rb_define_alloc_func(cLegPool.klass, _wrap_LegPool_allocate);
  rb_define_method(cLegPool.klass, "initialize", VALUEFUNC(_wrap_new_LegPool), -1);
  cLegPool.mark = 0;
  cLegPool.destroy = (void (*)(void *)) free_FIX_LegPool;
  cLegPool.trackObjects = 0;
  
  cShortQty.klass = rb_define_class_under(mQuickfix, "ShortQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ShortQty, (void *) &cShortQty);
  rb_define_alloc_func(cShortQty.klass, _wrap_ShortQty_allocate);
  rb_define_method(cShortQty.klass, "initialize", VALUEFUNC(_wrap_new_ShortQty), -1);
  cShortQty.mark = 0;
  cShortQty.destroy = (void (*)(void *)) free_FIX_ShortQty;
  cShortQty.trackObjects = 0;
  
  cSideValue2.klass = rb_define_class_under(mQuickfix, "SideValue2", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideValue2, (void *) &cSideValue2);
  rb_define_alloc_func(cSideValue2.klass, _wrap_SideValue2_allocate);
  rb_define_method(cSideValue2.klass, "initialize", VALUEFUNC(_wrap_new_SideValue2), -1);
  cSideValue2.mark = 0;
  cSideValue2.destroy = (void (*)(void *)) free_FIX_SideValue2;
  cSideValue2.trackObjects = 0;
  
  cTradedFlatSwitch.klass = rb_define_class_under(mQuickfix, "TradedFlatSwitch", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradedFlatSwitch, (void *) &cTradedFlatSwitch);
  rb_define_alloc_func(cTradedFlatSwitch.klass, _wrap_TradedFlatSwitch_allocate);
  rb_define_method(cTradedFlatSwitch.klass, "initialize", VALUEFUNC(_wrap_new_TradedFlatSwitch), -1);
  cTradedFlatSwitch.mark = 0;
  cTradedFlatSwitch.destroy = (void (*)(void *)) free_FIX_TradedFlatSwitch;
  cTradedFlatSwitch.trackObjects = 0;
  
  cMassStatusReqID.klass = rb_define_class_under(mQuickfix, "MassStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MassStatusReqID, (void *) &cMassStatusReqID);
  rb_define_alloc_func(cMassStatusReqID.klass, _wrap_MassStatusReqID_allocate);
  rb_define_method(cMassStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_MassStatusReqID), -1);
  cMassStatusReqID.mark = 0;
  cMassStatusReqID.destroy = (void (*)(void *)) free_FIX_MassStatusReqID;
  cMassStatusReqID.trackObjects = 0;
  
  cComplexEventEndDate.klass = rb_define_class_under(mQuickfix, "ComplexEventEndDate", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventEndDate, (void *) &cComplexEventEndDate);
  rb_define_alloc_func(cComplexEventEndDate.klass, _wrap_ComplexEventEndDate_allocate);
  rb_define_method(cComplexEventEndDate.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventEndDate), -1);
  cComplexEventEndDate.mark = 0;
  cComplexEventEndDate.destroy = (void (*)(void *)) free_FIX_ComplexEventEndDate;
  cComplexEventEndDate.trackObjects = 0;
  
  cMarketID.klass = rb_define_class_under(mQuickfix, "MarketID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketID, (void *) &cMarketID);
  rb_define_alloc_func(cMarketID.klass, _wrap_MarketID_allocate);
  rb_define_method(cMarketID.klass, "initialize", VALUEFUNC(_wrap_new_MarketID), -1);
  cMarketID.mark = 0;
  cMarketID.destroy = (void (*)(void *)) free_FIX_MarketID;
  cMarketID.trackObjects = 0;
  
  cOrigTradeDate.klass = rb_define_class_under(mQuickfix, "OrigTradeDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTradeDate, (void *) &cOrigTradeDate);
  rb_define_alloc_func(cOrigTradeDate.klass, _wrap_OrigTradeDate_allocate);
  rb_define_method(cOrigTradeDate.klass, "initialize", VALUEFUNC(_wrap_new_OrigTradeDate), -1);
  cOrigTradeDate.mark = 0;
  cOrigTradeDate.destroy = (void (*)(void *)) free_FIX_OrigTradeDate;
  cOrigTradeDate.trackObjects = 0;
  
  cPreTradeAnonymity.klass = rb_define_class_under(mQuickfix, "PreTradeAnonymity", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PreTradeAnonymity, (void *) &cPreTradeAnonymity);
  rb_define_alloc_func(cPreTradeAnonymity.klass, _wrap_PreTradeAnonymity_allocate);
  rb_define_method(cPreTradeAnonymity.klass, "initialize", VALUEFUNC(_wrap_new_PreTradeAnonymity), -1);
  cPreTradeAnonymity.mark = 0;
  cPreTradeAnonymity.destroy = (void (*)(void *)) free_FIX_PreTradeAnonymity;
  cPreTradeAnonymity.trackObjects = 0;
  
  cTrdRptStatus.klass = rb_define_class_under(mQuickfix, "TrdRptStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRptStatus, (void *) &cTrdRptStatus);
  rb_define_alloc_func(cTrdRptStatus.klass, _wrap_TrdRptStatus_allocate);
  rb_define_method(cTrdRptStatus.klass, "initialize", VALUEFUNC(_wrap_new_TrdRptStatus), -1);
  cTrdRptStatus.mark = 0;
  cTrdRptStatus.destroy = (void (*)(void *)) free_FIX_TrdRptStatus;
  cTrdRptStatus.trackObjects = 0;
  
  cDistribPercentage.klass = rb_define_class_under(mQuickfix, "DistribPercentage", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DistribPercentage, (void *) &cDistribPercentage);
  rb_define_alloc_func(cDistribPercentage.klass, _wrap_DistribPercentage_allocate);
  rb_define_method(cDistribPercentage.klass, "initialize", VALUEFUNC(_wrap_new_DistribPercentage), -1);
  cDistribPercentage.mark = 0;
  cDistribPercentage.destroy = (void (*)(void *)) free_FIX_DistribPercentage;
  cDistribPercentage.trackObjects = 0;
  
  cQuoteStatus.klass = rb_define_class_under(mQuickfix, "QuoteStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteStatus, (void *) &cQuoteStatus);
  rb_define_alloc_func(cQuoteStatus.klass, _wrap_QuoteStatus_allocate);
  rb_define_method(cQuoteStatus.klass, "initialize", VALUEFUNC(_wrap_new_QuoteStatus), -1);
  cQuoteStatus.mark = 0;
  cQuoteStatus.destroy = (void (*)(void *)) free_FIX_QuoteStatus;
  cQuoteStatus.trackObjects = 0;
  
  cClearingAccount.klass = rb_define_class_under(mQuickfix, "ClearingAccount", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClearingAccount, (void *) &cClearingAccount);
  rb_define_alloc_func(cClearingAccount.klass, _wrap_ClearingAccount_allocate);
  rb_define_method(cClearingAccount.klass, "initialize", VALUEFUNC(_wrap_new_ClearingAccount), -1);
  cClearingAccount.mark = 0;
  cClearingAccount.destroy = (void (*)(void *)) free_FIX_ClearingAccount;
  cClearingAccount.trackObjects = 0;
  
  cTrdMatchID.klass = rb_define_class_under(mQuickfix, "TrdMatchID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdMatchID, (void *) &cTrdMatchID);
  rb_define_alloc_func(cTrdMatchID.klass, _wrap_TrdMatchID_allocate);
  rb_define_method(cTrdMatchID.klass, "initialize", VALUEFUNC(_wrap_new_TrdMatchID), -1);
  cTrdMatchID.mark = 0;
  cTrdMatchID.destroy = (void (*)(void *)) free_FIX_TrdMatchID;
  cTrdMatchID.trackObjects = 0;
  
  cOrderInputDevice.klass = rb_define_class_under(mQuickfix, "OrderInputDevice", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderInputDevice, (void *) &cOrderInputDevice);
  rb_define_alloc_func(cOrderInputDevice.klass, _wrap_OrderInputDevice_allocate);
  rb_define_method(cOrderInputDevice.klass, "initialize", VALUEFUNC(_wrap_new_OrderInputDevice), -1);
  cOrderInputDevice.mark = 0;
  cOrderInputDevice.destroy = (void (*)(void *)) free_FIX_OrderInputDevice;
  cOrderInputDevice.trackObjects = 0;
  
  cSolicitedFlag.klass = rb_define_class_under(mQuickfix, "SolicitedFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SolicitedFlag, (void *) &cSolicitedFlag);
  rb_define_alloc_func(cSolicitedFlag.klass, _wrap_SolicitedFlag_allocate);
  rb_define_method(cSolicitedFlag.klass, "initialize", VALUEFUNC(_wrap_new_SolicitedFlag), -1);
  cSolicitedFlag.mark = 0;
  cSolicitedFlag.destroy = (void (*)(void *)) free_FIX_SolicitedFlag;
  cSolicitedFlag.trackObjects = 0;
  
  cTransactTime.klass = rb_define_class_under(mQuickfix, "TransactTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TransactTime, (void *) &cTransactTime);
  rb_define_alloc_func(cTransactTime.klass, _wrap_TransactTime_allocate);
  rb_define_method(cTransactTime.klass, "initialize", VALUEFUNC(_wrap_new_TransactTime), -1);
  cTransactTime.mark = 0;
  cTransactTime.destroy = (void (*)(void *)) free_FIX_TransactTime;
  cTransactTime.trackObjects = 0;
  
  cRiskLimitType.klass = rb_define_class_under(mQuickfix, "RiskLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskLimitType, (void *) &cRiskLimitType);
  rb_define_alloc_func(cRiskLimitType.klass, _wrap_RiskLimitType_allocate);
  rb_define_method(cRiskLimitType.klass, "initialize", VALUEFUNC(_wrap_new_RiskLimitType), -1);
  cRiskLimitType.mark = 0;
  cRiskLimitType.destroy = (void (*)(void *)) free_FIX_RiskLimitType;
  cRiskLimitType.trackObjects = 0;
  
  cUnderlyingFlowScheduleType.klass = rb_define_class_under(mQuickfix, "UnderlyingFlowScheduleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFlowScheduleType, (void *) &cUnderlyingFlowScheduleType);
  rb_define_alloc_func(cUnderlyingFlowScheduleType.klass, _wrap_UnderlyingFlowScheduleType_allocate);
  rb_define_method(cUnderlyingFlowScheduleType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFlowScheduleType), -1);
  cUnderlyingFlowScheduleType.mark = 0;
  cUnderlyingFlowScheduleType.destroy = (void (*)(void *)) free_FIX_UnderlyingFlowScheduleType;
  cUnderlyingFlowScheduleType.trackObjects = 0;
  
  cUnderlyingStipValue.klass = rb_define_class_under(mQuickfix, "UnderlyingStipValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStipValue, (void *) &cUnderlyingStipValue);
  rb_define_alloc_func(cUnderlyingStipValue.klass, _wrap_UnderlyingStipValue_allocate);
  rb_define_method(cUnderlyingStipValue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStipValue), -1);
  cUnderlyingStipValue.mark = 0;
  cUnderlyingStipValue.destroy = (void (*)(void *)) free_FIX_UnderlyingStipValue;
  cUnderlyingStipValue.trackObjects = 0;
  
  cNextExpectedMsgSeqNum.klass = rb_define_class_under(mQuickfix, "NextExpectedMsgSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NextExpectedMsgSeqNum, (void *) &cNextExpectedMsgSeqNum);
  rb_define_alloc_func(cNextExpectedMsgSeqNum.klass, _wrap_NextExpectedMsgSeqNum_allocate);
  rb_define_method(cNextExpectedMsgSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_NextExpectedMsgSeqNum), -1);
  cNextExpectedMsgSeqNum.mark = 0;
  cNextExpectedMsgSeqNum.destroy = (void (*)(void *)) free_FIX_NextExpectedMsgSeqNum;
  cNextExpectedMsgSeqNum.trackObjects = 0;
  
  cBenchmarkCurveCurrency.klass = rb_define_class_under(mQuickfix, "BenchmarkCurveCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkCurveCurrency, (void *) &cBenchmarkCurveCurrency);
  rb_define_alloc_func(cBenchmarkCurveCurrency.klass, _wrap_BenchmarkCurveCurrency_allocate);
  rb_define_method(cBenchmarkCurveCurrency.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkCurveCurrency), -1);
  cBenchmarkCurveCurrency.mark = 0;
  cBenchmarkCurveCurrency.destroy = (void (*)(void *)) free_FIX_BenchmarkCurveCurrency;
  cBenchmarkCurveCurrency.trackObjects = 0;
  
  cCFICode.klass = rb_define_class_under(mQuickfix, "CFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CFICode, (void *) &cCFICode);
  rb_define_alloc_func(cCFICode.klass, _wrap_CFICode_allocate);
  rb_define_method(cCFICode.klass, "initialize", VALUEFUNC(_wrap_new_CFICode), -1);
  cCFICode.mark = 0;
  cCFICode.destroy = (void (*)(void *)) free_FIX_CFICode;
  cCFICode.trackObjects = 0;
  
  cFactor.klass = rb_define_class_under(mQuickfix, "Factor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Factor, (void *) &cFactor);
  rb_define_alloc_func(cFactor.klass, _wrap_Factor_allocate);
  rb_define_method(cFactor.klass, "initialize", VALUEFUNC(_wrap_new_Factor), -1);
  cFactor.mark = 0;
  cFactor.destroy = (void (*)(void *)) free_FIX_Factor;
  cFactor.trackObjects = 0;
  
  cLastShares.klass = rb_define_class_under(mQuickfix, "LastShares", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastShares, (void *) &cLastShares);
  rb_define_alloc_func(cLastShares.klass, _wrap_LastShares_allocate);
  rb_define_method(cLastShares.klass, "initialize", VALUEFUNC(_wrap_new_LastShares), -1);
  cLastShares.mark = 0;
  cLastShares.destroy = (void (*)(void *)) free_FIX_LastShares;
  cLastShares.trackObjects = 0;
  
  cRequestedPartyRole.klass = rb_define_class_under(mQuickfix, "RequestedPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RequestedPartyRole, (void *) &cRequestedPartyRole);
  rb_define_alloc_func(cRequestedPartyRole.klass, _wrap_RequestedPartyRole_allocate);
  rb_define_method(cRequestedPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_RequestedPartyRole), -1);
  cRequestedPartyRole.mark = 0;
  cRequestedPartyRole.destroy = (void (*)(void *)) free_FIX_RequestedPartyRole;
  cRequestedPartyRole.trackObjects = 0;
  
  cEventTime.klass = rb_define_class_under(mQuickfix, "EventTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventTime, (void *) &cEventTime);
  rb_define_alloc_func(cEventTime.klass, _wrap_EventTime_allocate);
  rb_define_method(cEventTime.klass, "initialize", VALUEFUNC(_wrap_new_EventTime), -1);
  cEventTime.mark = 0;
  cEventTime.destroy = (void (*)(void *)) free_FIX_EventTime;
  cEventTime.trackObjects = 0;
  
  cRootPartySubIDType.klass = rb_define_class_under(mQuickfix, "RootPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartySubIDType, (void *) &cRootPartySubIDType);
  rb_define_alloc_func(cRootPartySubIDType.klass, _wrap_RootPartySubIDType_allocate);
  rb_define_method(cRootPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_RootPartySubIDType), -1);
  cRootPartySubIDType.mark = 0;
  cRootPartySubIDType.destroy = (void (*)(void *)) free_FIX_RootPartySubIDType;
  cRootPartySubIDType.trackObjects = 0;
  
  cShortSaleReason.klass = rb_define_class_under(mQuickfix, "ShortSaleReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ShortSaleReason, (void *) &cShortSaleReason);
  rb_define_alloc_func(cShortSaleReason.klass, _wrap_ShortSaleReason_allocate);
  rb_define_method(cShortSaleReason.klass, "initialize", VALUEFUNC(_wrap_new_ShortSaleReason), -1);
  cShortSaleReason.mark = 0;
  cShortSaleReason.destroy = (void (*)(void *)) free_FIX_ShortSaleReason;
  cShortSaleReason.trackObjects = 0;
  
  cXmlData.klass = rb_define_class_under(mQuickfix, "XmlData", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__XmlData, (void *) &cXmlData);
  rb_define_alloc_func(cXmlData.klass, _wrap_XmlData_allocate);
  rb_define_method(cXmlData.klass, "initialize", VALUEFUNC(_wrap_new_XmlData), -1);
  cXmlData.mark = 0;
  cXmlData.destroy = (void (*)(void *)) free_FIX_XmlData;
  cXmlData.trackObjects = 0;
  
  cRelationshipRiskSeniority.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSeniority", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSeniority, (void *) &cRelationshipRiskSeniority);
  rb_define_alloc_func(cRelationshipRiskSeniority.klass, _wrap_RelationshipRiskSeniority_allocate);
  rb_define_method(cRelationshipRiskSeniority.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSeniority), -1);
  cRelationshipRiskSeniority.mark = 0;
  cRelationshipRiskSeniority.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSeniority;
  cRelationshipRiskSeniority.trackObjects = 0;
  
  cNoTargetPartyIDs.klass = rb_define_class_under(mQuickfix, "NoTargetPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTargetPartyIDs, (void *) &cNoTargetPartyIDs);
  rb_define_alloc_func(cNoTargetPartyIDs.klass, _wrap_NoTargetPartyIDs_allocate);
  rb_define_method(cNoTargetPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoTargetPartyIDs), -1);
  cNoTargetPartyIDs.mark = 0;
  cNoTargetPartyIDs.destroy = (void (*)(void *)) free_FIX_NoTargetPartyIDs;
  cNoTargetPartyIDs.trackObjects = 0;
  
  cNoRootPartyIDs.klass = rb_define_class_under(mQuickfix, "NoRootPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRootPartyIDs, (void *) &cNoRootPartyIDs);
  rb_define_alloc_func(cNoRootPartyIDs.klass, _wrap_NoRootPartyIDs_allocate);
  rb_define_method(cNoRootPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRootPartyIDs), -1);
  cNoRootPartyIDs.mark = 0;
  cNoRootPartyIDs.destroy = (void (*)(void *)) free_FIX_NoRootPartyIDs;
  cNoRootPartyIDs.trackObjects = 0;
  
  cEventDate.klass = rb_define_class_under(mQuickfix, "EventDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventDate, (void *) &cEventDate);
  rb_define_alloc_func(cEventDate.klass, _wrap_EventDate_allocate);
  rb_define_method(cEventDate.klass, "initialize", VALUEFUNC(_wrap_new_EventDate), -1);
  cEventDate.mark = 0;
  cEventDate.destroy = (void (*)(void *)) free_FIX_EventDate;
  cEventDate.trackObjects = 0;
  
  cPegRoundDirection.klass = rb_define_class_under(mQuickfix, "PegRoundDirection", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegRoundDirection, (void *) &cPegRoundDirection);
  rb_define_alloc_func(cPegRoundDirection.klass, _wrap_PegRoundDirection_allocate);
  rb_define_method(cPegRoundDirection.klass, "initialize", VALUEFUNC(_wrap_new_PegRoundDirection), -1);
  cPegRoundDirection.mark = 0;
  cPegRoundDirection.destroy = (void (*)(void *)) free_FIX_PegRoundDirection;
  cPegRoundDirection.trackObjects = 0;
  
  cLegSettlDate.klass = rb_define_class_under(mQuickfix, "LegSettlDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSettlDate, (void *) &cLegSettlDate);
  rb_define_alloc_func(cLegSettlDate.klass, _wrap_LegSettlDate_allocate);
  rb_define_method(cLegSettlDate.klass, "initialize", VALUEFUNC(_wrap_new_LegSettlDate), -1);
  cLegSettlDate.mark = 0;
  cLegSettlDate.destroy = (void (*)(void *)) free_FIX_LegSettlDate;
  cLegSettlDate.trackObjects = 0;
  
  cModelType.klass = rb_define_class_under(mQuickfix, "ModelType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ModelType, (void *) &cModelType);
  rb_define_alloc_func(cModelType.klass, _wrap_ModelType_allocate);
  rb_define_method(cModelType.klass, "initialize", VALUEFUNC(_wrap_new_ModelType), -1);
  cModelType.mark = 0;
  cModelType.destroy = (void (*)(void *)) free_FIX_ModelType;
  cModelType.trackObjects = 0;
  
  cDefaultVerIndicator.klass = rb_define_class_under(mQuickfix, "DefaultVerIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultVerIndicator, (void *) &cDefaultVerIndicator);
  rb_define_alloc_func(cDefaultVerIndicator.klass, _wrap_DefaultVerIndicator_allocate);
  rb_define_method(cDefaultVerIndicator.klass, "initialize", VALUEFUNC(_wrap_new_DefaultVerIndicator), -1);
  cDefaultVerIndicator.mark = 0;
  cDefaultVerIndicator.destroy = (void (*)(void *)) free_FIX_DefaultVerIndicator;
  cDefaultVerIndicator.trackObjects = 0;
  
  cFuturesValuationMethod.klass = rb_define_class_under(mQuickfix, "FuturesValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FuturesValuationMethod, (void *) &cFuturesValuationMethod);
  rb_define_alloc_func(cFuturesValuationMethod.klass, _wrap_FuturesValuationMethod_allocate);
  rb_define_method(cFuturesValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_FuturesValuationMethod), -1);
  cFuturesValuationMethod.mark = 0;
  cFuturesValuationMethod.destroy = (void (*)(void *)) free_FIX_FuturesValuationMethod;
  cFuturesValuationMethod.trackObjects = 0;
  
  cSettlMethod.klass = rb_define_class_under(mQuickfix, "SettlMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlMethod, (void *) &cSettlMethod);
  rb_define_alloc_func(cSettlMethod.klass, _wrap_SettlMethod_allocate);
  rb_define_method(cSettlMethod.klass, "initialize", VALUEFUNC(_wrap_new_SettlMethod), -1);
  cSettlMethod.mark = 0;
  cSettlMethod.destroy = (void (*)(void *)) free_FIX_SettlMethod;
  cSettlMethod.trackObjects = 0;
  
  cUnderlyingFXRate.klass = rb_define_class_under(mQuickfix, "UnderlyingFXRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFXRate, (void *) &cUnderlyingFXRate);
  rb_define_alloc_func(cUnderlyingFXRate.klass, _wrap_UnderlyingFXRate_allocate);
  rb_define_method(cUnderlyingFXRate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFXRate), -1);
  cUnderlyingFXRate.mark = 0;
  cUnderlyingFXRate.destroy = (void (*)(void *)) free_FIX_UnderlyingFXRate;
  cUnderlyingFXRate.trackObjects = 0;
  
  cConfirmStatus.klass = rb_define_class_under(mQuickfix, "ConfirmStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmStatus, (void *) &cConfirmStatus);
  rb_define_alloc_func(cConfirmStatus.klass, _wrap_ConfirmStatus_allocate);
  rb_define_method(cConfirmStatus.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmStatus), -1);
  cConfirmStatus.mark = 0;
  cConfirmStatus.destroy = (void (*)(void *)) free_FIX_ConfirmStatus;
  cConfirmStatus.trackObjects = 0;
  
  cLocateReqd.klass = rb_define_class_under(mQuickfix, "LocateReqd", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LocateReqd, (void *) &cLocateReqd);
  rb_define_alloc_func(cLocateReqd.klass, _wrap_LocateReqd_allocate);
  rb_define_method(cLocateReqd.klass, "initialize", VALUEFUNC(_wrap_new_LocateReqd), -1);
  cLocateReqd.mark = 0;
  cLocateReqd.destroy = (void (*)(void *)) free_FIX_LocateReqd;
  cLocateReqd.trackObjects = 0;
  
  cPosMaintRptID.klass = rb_define_class_under(mQuickfix, "PosMaintRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintRptID, (void *) &cPosMaintRptID);
  rb_define_alloc_func(cPosMaintRptID.klass, _wrap_PosMaintRptID_allocate);
  rb_define_method(cPosMaintRptID.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintRptID), -1);
  cPosMaintRptID.mark = 0;
  cPosMaintRptID.destroy = (void (*)(void *)) free_FIX_PosMaintRptID;
  cPosMaintRptID.trackObjects = 0;
  
  cAdjustment.klass = rb_define_class_under(mQuickfix, "Adjustment", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Adjustment, (void *) &cAdjustment);
  rb_define_alloc_func(cAdjustment.klass, _wrap_Adjustment_allocate);
  rb_define_method(cAdjustment.klass, "initialize", VALUEFUNC(_wrap_new_Adjustment), -1);
  cAdjustment.mark = 0;
  cAdjustment.destroy = (void (*)(void *)) free_FIX_Adjustment;
  cAdjustment.trackObjects = 0;
  
  cStreamAsgnType.klass = rb_define_class_under(mQuickfix, "StreamAsgnType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnType, (void *) &cStreamAsgnType);
  rb_define_alloc_func(cStreamAsgnType.klass, _wrap_StreamAsgnType_allocate);
  rb_define_method(cStreamAsgnType.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnType), -1);
  cStreamAsgnType.mark = 0;
  cStreamAsgnType.destroy = (void (*)(void *)) free_FIX_StreamAsgnType;
  cStreamAsgnType.trackObjects = 0;
  
  cLastRptRequested.klass = rb_define_class_under(mQuickfix, "LastRptRequested", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastRptRequested, (void *) &cLastRptRequested);
  rb_define_alloc_func(cLastRptRequested.klass, _wrap_LastRptRequested_allocate);
  rb_define_method(cLastRptRequested.klass, "initialize", VALUEFUNC(_wrap_new_LastRptRequested), -1);
  cLastRptRequested.mark = 0;
  cLastRptRequested.destroy = (void (*)(void *)) free_FIX_LastRptRequested;
  cLastRptRequested.trackObjects = 0;
  
  cLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "LocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LocaleOfIssue, (void *) &cLocaleOfIssue);
  rb_define_alloc_func(cLocaleOfIssue.klass, _wrap_LocaleOfIssue_allocate);
  rb_define_method(cLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LocaleOfIssue), -1);
  cLocaleOfIssue.mark = 0;
  cLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_LocaleOfIssue;
  cLocaleOfIssue.trackObjects = 0;
  
  cSenderSubID.klass = rb_define_class_under(mQuickfix, "SenderSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SenderSubID, (void *) &cSenderSubID);
  rb_define_alloc_func(cSenderSubID.klass, _wrap_SenderSubID_allocate);
  rb_define_method(cSenderSubID.klass, "initialize", VALUEFUNC(_wrap_new_SenderSubID), -1);
  cSenderSubID.mark = 0;
  cSenderSubID.destroy = (void (*)(void *)) free_FIX_SenderSubID;
  cSenderSubID.trackObjects = 0;
  
  cHighPx.klass = rb_define_class_under(mQuickfix, "HighPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HighPx, (void *) &cHighPx);
  rb_define_alloc_func(cHighPx.klass, _wrap_HighPx_allocate);
  rb_define_method(cHighPx.klass, "initialize", VALUEFUNC(_wrap_new_HighPx), -1);
  cHighPx.mark = 0;
  cHighPx.destroy = (void (*)(void *)) free_FIX_HighPx;
  cHighPx.trackObjects = 0;
  
  cAllocSettlCurrAmt.klass = rb_define_class_under(mQuickfix, "AllocSettlCurrAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocSettlCurrAmt, (void *) &cAllocSettlCurrAmt);
  rb_define_alloc_func(cAllocSettlCurrAmt.klass, _wrap_AllocSettlCurrAmt_allocate);
  rb_define_method(cAllocSettlCurrAmt.klass, "initialize", VALUEFUNC(_wrap_new_AllocSettlCurrAmt), -1);
  cAllocSettlCurrAmt.mark = 0;
  cAllocSettlCurrAmt.destroy = (void (*)(void *)) free_FIX_AllocSettlCurrAmt;
  cAllocSettlCurrAmt.trackObjects = 0;
  
  cComplexEventPriceBoundaryPrecision.klass = rb_define_class_under(mQuickfix, "ComplexEventPriceBoundaryPrecision", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision, (void *) &cComplexEventPriceBoundaryPrecision);
  rb_define_alloc_func(cComplexEventPriceBoundaryPrecision.klass, _wrap_ComplexEventPriceBoundaryPrecision_allocate);
  rb_define_method(cComplexEventPriceBoundaryPrecision.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPriceBoundaryPrecision), -1);
  cComplexEventPriceBoundaryPrecision.mark = 0;
  cComplexEventPriceBoundaryPrecision.destroy = (void (*)(void *)) free_FIX_ComplexEventPriceBoundaryPrecision;
  cComplexEventPriceBoundaryPrecision.trackObjects = 0;
  
  cInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "InstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartyRole, (void *) &cInstrumentPartyRole);
  rb_define_alloc_func(cInstrumentPartyRole.klass, _wrap_InstrumentPartyRole_allocate);
  rb_define_method(cInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartyRole), -1);
  cInstrumentPartyRole.mark = 0;
  cInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_InstrumentPartyRole;
  cInstrumentPartyRole.trackObjects = 0;
  
  cYieldRedemptionPrice.klass = rb_define_class_under(mQuickfix, "YieldRedemptionPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldRedemptionPrice, (void *) &cYieldRedemptionPrice);
  rb_define_alloc_func(cYieldRedemptionPrice.klass, _wrap_YieldRedemptionPrice_allocate);
  rb_define_method(cYieldRedemptionPrice.klass, "initialize", VALUEFUNC(_wrap_new_YieldRedemptionPrice), -1);
  cYieldRedemptionPrice.mark = 0;
  cYieldRedemptionPrice.destroy = (void (*)(void *)) free_FIX_YieldRedemptionPrice;
  cYieldRedemptionPrice.trackObjects = 0;
  
  cCumQty.klass = rb_define_class_under(mQuickfix, "CumQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CumQty, (void *) &cCumQty);
  rb_define_alloc_func(cCumQty.klass, _wrap_CumQty_allocate);
  rb_define_method(cCumQty.klass, "initialize", VALUEFUNC(_wrap_new_CumQty), -1);
  cCumQty.mark = 0;
  cCumQty.destroy = (void (*)(void *)) free_FIX_CumQty;
  cCumQty.trackObjects = 0;
  
  cOrigClOrdID.klass = rb_define_class_under(mQuickfix, "OrigClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigClOrdID, (void *) &cOrigClOrdID);
  rb_define_alloc_func(cOrigClOrdID.klass, _wrap_OrigClOrdID_allocate);
  rb_define_method(cOrigClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_OrigClOrdID), -1);
  cOrigClOrdID.mark = 0;
  cOrigClOrdID.destroy = (void (*)(void *)) free_FIX_OrigClOrdID;
  cOrigClOrdID.trackObjects = 0;
  
  cSettlSessID.klass = rb_define_class_under(mQuickfix, "SettlSessID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlSessID, (void *) &cSettlSessID);
  rb_define_alloc_func(cSettlSessID.klass, _wrap_SettlSessID_allocate);
  rb_define_method(cSettlSessID.klass, "initialize", VALUEFUNC(_wrap_new_SettlSessID), -1);
  cSettlSessID.mark = 0;
  cSettlSessID.destroy = (void (*)(void *)) free_FIX_SettlSessID;
  cSettlSessID.trackObjects = 0;
  
  cParentMktSegmID.klass = rb_define_class_under(mQuickfix, "ParentMktSegmID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ParentMktSegmID, (void *) &cParentMktSegmID);
  rb_define_alloc_func(cParentMktSegmID.klass, _wrap_ParentMktSegmID_allocate);
  rb_define_method(cParentMktSegmID.klass, "initialize", VALUEFUNC(_wrap_new_ParentMktSegmID), -1);
  cParentMktSegmID.mark = 0;
  cParentMktSegmID.destroy = (void (*)(void *)) free_FIX_ParentMktSegmID;
  cParentMktSegmID.trackObjects = 0;
  
  cTradeReportType.klass = rb_define_class_under(mQuickfix, "TradeReportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeReportType, (void *) &cTradeReportType);
  rb_define_alloc_func(cTradeReportType.klass, _wrap_TradeReportType_allocate);
  rb_define_method(cTradeReportType.klass, "initialize", VALUEFUNC(_wrap_new_TradeReportType), -1);
  cTradeReportType.mark = 0;
  cTradeReportType.destroy = (void (*)(void *)) free_FIX_TradeReportType;
  cTradeReportType.trackObjects = 0;
  
  cAvgPrxPrecision.klass = rb_define_class_under(mQuickfix, "AvgPrxPrecision", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPrxPrecision, (void *) &cAvgPrxPrecision);
  rb_define_alloc_func(cAvgPrxPrecision.klass, _wrap_AvgPrxPrecision_allocate);
  rb_define_method(cAvgPrxPrecision.klass, "initialize", VALUEFUNC(_wrap_new_AvgPrxPrecision), -1);
  cAvgPrxPrecision.mark = 0;
  cAvgPrxPrecision.destroy = (void (*)(void *)) free_FIX_AvgPrxPrecision;
  cAvgPrxPrecision.trackObjects = 0;
  
  cNoLegs.klass = rb_define_class_under(mQuickfix, "NoLegs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLegs, (void *) &cNoLegs);
  rb_define_alloc_func(cNoLegs.klass, _wrap_NoLegs_allocate);
  rb_define_method(cNoLegs.klass, "initialize", VALUEFUNC(_wrap_new_NoLegs), -1);
  cNoLegs.mark = 0;
  cNoLegs.destroy = (void (*)(void *)) free_FIX_NoLegs;
  cNoLegs.trackObjects = 0;
  
  cUnderlyingSymbol.klass = rb_define_class_under(mQuickfix, "UnderlyingSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSymbol, (void *) &cUnderlyingSymbol);
  rb_define_alloc_func(cUnderlyingSymbol.klass, _wrap_UnderlyingSymbol_allocate);
  rb_define_method(cUnderlyingSymbol.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSymbol), -1);
  cUnderlyingSymbol.mark = 0;
  cUnderlyingSymbol.destroy = (void (*)(void *)) free_FIX_UnderlyingSymbol;
  cUnderlyingSymbol.trackObjects = 0;
  
  cExerciseStyle.klass = rb_define_class_under(mQuickfix, "ExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExerciseStyle, (void *) &cExerciseStyle);
  rb_define_alloc_func(cExerciseStyle.klass, _wrap_ExerciseStyle_allocate);
  rb_define_method(cExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_ExerciseStyle), -1);
  cExerciseStyle.mark = 0;
  cExerciseStyle.destroy = (void (*)(void *)) free_FIX_ExerciseStyle;
  cExerciseStyle.trackObjects = 0;
  
  cHaltReasonChar.klass = rb_define_class_under(mQuickfix, "HaltReasonChar", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HaltReasonChar, (void *) &cHaltReasonChar);
  rb_define_alloc_func(cHaltReasonChar.klass, _wrap_HaltReasonChar_allocate);
  rb_define_method(cHaltReasonChar.klass, "initialize", VALUEFUNC(_wrap_new_HaltReasonChar), -1);
  cHaltReasonChar.mark = 0;
  cHaltReasonChar.destroy = (void (*)(void *)) free_FIX_HaltReasonChar;
  cHaltReasonChar.trackObjects = 0;
  
  cExDestination.klass = rb_define_class_under(mQuickfix, "ExDestination", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExDestination, (void *) &cExDestination);
  rb_define_alloc_func(cExDestination.klass, _wrap_ExDestination_allocate);
  rb_define_method(cExDestination.klass, "initialize", VALUEFUNC(_wrap_new_ExDestination), -1);
  cExDestination.mark = 0;
  cExDestination.destroy = (void (*)(void *)) free_FIX_ExDestination;
  cExDestination.trackObjects = 0;
  
  cNoPartyRelationships.klass = rb_define_class_under(mQuickfix, "NoPartyRelationships", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartyRelationships, (void *) &cNoPartyRelationships);
  rb_define_alloc_func(cNoPartyRelationships.klass, _wrap_NoPartyRelationships_allocate);
  rb_define_method(cNoPartyRelationships.klass, "initialize", VALUEFUNC(_wrap_new_NoPartyRelationships), -1);
  cNoPartyRelationships.mark = 0;
  cNoPartyRelationships.destroy = (void (*)(void *)) free_FIX_NoPartyRelationships;
  cNoPartyRelationships.trackObjects = 0;
  
  cDerivativeInstrmtAssignmentMethod.klass = rb_define_class_under(mQuickfix, "DerivativeInstrmtAssignmentMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod, (void *) &cDerivativeInstrmtAssignmentMethod);
  rb_define_alloc_func(cDerivativeInstrmtAssignmentMethod.klass, _wrap_DerivativeInstrmtAssignmentMethod_allocate);
  rb_define_method(cDerivativeInstrmtAssignmentMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrmtAssignmentMethod), -1);
  cDerivativeInstrmtAssignmentMethod.mark = 0;
  cDerivativeInstrmtAssignmentMethod.destroy = (void (*)(void *)) free_FIX_DerivativeInstrmtAssignmentMethod;
  cDerivativeInstrmtAssignmentMethod.trackObjects = 0;
  
  cUnderlyingIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingIDSource, (void *) &cUnderlyingIDSource);
  rb_define_alloc_func(cUnderlyingIDSource.klass, _wrap_UnderlyingIDSource_allocate);
  rb_define_method(cUnderlyingIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingIDSource), -1);
  cUnderlyingIDSource.mark = 0;
  cUnderlyingIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingIDSource;
  cUnderlyingIDSource.trackObjects = 0;
  
  cAdvId.klass = rb_define_class_under(mQuickfix, "AdvId", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvId, (void *) &cAdvId);
  rb_define_alloc_func(cAdvId.klass, _wrap_AdvId_allocate);
  rb_define_method(cAdvId.klass, "initialize", VALUEFUNC(_wrap_new_AdvId), -1);
  cAdvId.mark = 0;
  cAdvId.destroy = (void (*)(void *)) free_FIX_AdvId;
  cAdvId.trackObjects = 0;
  
  cTransBkdTime.klass = rb_define_class_under(mQuickfix, "TransBkdTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TransBkdTime, (void *) &cTransBkdTime);
  rb_define_alloc_func(cTransBkdTime.klass, _wrap_TransBkdTime_allocate);
  rb_define_method(cTransBkdTime.klass, "initialize", VALUEFUNC(_wrap_new_TransBkdTime), -1);
  cTransBkdTime.mark = 0;
  cTransBkdTime.destroy = (void (*)(void *)) free_FIX_TransBkdTime;
  cTransBkdTime.trackObjects = 0;
  
  cLegLastPx.klass = rb_define_class_under(mQuickfix, "LegLastPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLastPx, (void *) &cLegLastPx);
  rb_define_alloc_func(cLegLastPx.klass, _wrap_LegLastPx_allocate);
  rb_define_method(cLegLastPx.klass, "initialize", VALUEFUNC(_wrap_new_LegLastPx), -1);
  cLegLastPx.mark = 0;
  cLegLastPx.destroy = (void (*)(void *)) free_FIX_LegLastPx;
  cLegLastPx.trackObjects = 0;
  
  cNoRiskWarningLevels.klass = rb_define_class_under(mQuickfix, "NoRiskWarningLevels", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRiskWarningLevels, (void *) &cNoRiskWarningLevels);
  rb_define_alloc_func(cNoRiskWarningLevels.klass, _wrap_NoRiskWarningLevels_allocate);
  rb_define_method(cNoRiskWarningLevels.klass, "initialize", VALUEFUNC(_wrap_new_NoRiskWarningLevels), -1);
  cNoRiskWarningLevels.mark = 0;
  cNoRiskWarningLevels.destroy = (void (*)(void *)) free_FIX_NoRiskWarningLevels;
  cNoRiskWarningLevels.trackObjects = 0;
  
  cAllocReportType.klass = rb_define_class_under(mQuickfix, "AllocReportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocReportType, (void *) &cAllocReportType);
  rb_define_alloc_func(cAllocReportType.klass, _wrap_AllocReportType_allocate);
  rb_define_method(cAllocReportType.klass, "initialize", VALUEFUNC(_wrap_new_AllocReportType), -1);
  cAllocReportType.mark = 0;
  cAllocReportType.destroy = (void (*)(void *)) free_FIX_AllocReportType;
  cAllocReportType.trackObjects = 0;
  
  cRegistDtls.klass = rb_define_class_under(mQuickfix, "RegistDtls", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistDtls, (void *) &cRegistDtls);
  rb_define_alloc_func(cRegistDtls.klass, _wrap_RegistDtls_allocate);
  rb_define_method(cRegistDtls.klass, "initialize", VALUEFUNC(_wrap_new_RegistDtls), -1);
  cRegistDtls.mark = 0;
  cRegistDtls.destroy = (void (*)(void *)) free_FIX_RegistDtls;
  cRegistDtls.trackObjects = 0;
  
  cAllocType.klass = rb_define_class_under(mQuickfix, "AllocType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocType, (void *) &cAllocType);
  rb_define_alloc_func(cAllocType.klass, _wrap_AllocType_allocate);
  rb_define_method(cAllocType.klass, "initialize", VALUEFUNC(_wrap_new_AllocType), -1);
  cAllocType.mark = 0;
  cAllocType.destroy = (void (*)(void *)) free_FIX_AllocType;
  cAllocType.trackObjects = 0;
  
  cQuoteRequestRejectReason.klass = rb_define_class_under(mQuickfix, "QuoteRequestRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRequestRejectReason, (void *) &cQuoteRequestRejectReason);
  rb_define_alloc_func(cQuoteRequestRejectReason.klass, _wrap_QuoteRequestRejectReason_allocate);
  rb_define_method(cQuoteRequestRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRequestRejectReason), -1);
  cQuoteRequestRejectReason.mark = 0;
  cQuoteRequestRejectReason.destroy = (void (*)(void *)) free_FIX_QuoteRequestRejectReason;
  cQuoteRequestRejectReason.trackObjects = 0;
  
  cUnderlyingUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "UnderlyingUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure, (void *) &cUnderlyingUnitOfMeasure);
  rb_define_alloc_func(cUnderlyingUnitOfMeasure.klass, _wrap_UnderlyingUnitOfMeasure_allocate);
  rb_define_method(cUnderlyingUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingUnitOfMeasure), -1);
  cUnderlyingUnitOfMeasure.mark = 0;
  cUnderlyingUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_UnderlyingUnitOfMeasure;
  cUnderlyingUnitOfMeasure.trackObjects = 0;
  
  cIndividualAllocID.klass = rb_define_class_under(mQuickfix, "IndividualAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IndividualAllocID, (void *) &cIndividualAllocID);
  rb_define_alloc_func(cIndividualAllocID.klass, _wrap_IndividualAllocID_allocate);
  rb_define_method(cIndividualAllocID.klass, "initialize", VALUEFUNC(_wrap_new_IndividualAllocID), -1);
  cIndividualAllocID.mark = 0;
  cIndividualAllocID.destroy = (void (*)(void *)) free_FIX_IndividualAllocID;
  cIndividualAllocID.trackObjects = 0;
  
  cLegOfferPx.klass = rb_define_class_under(mQuickfix, "LegOfferPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOfferPx, (void *) &cLegOfferPx);
  rb_define_alloc_func(cLegOfferPx.klass, _wrap_LegOfferPx_allocate);
  rb_define_method(cLegOfferPx.klass, "initialize", VALUEFUNC(_wrap_new_LegOfferPx), -1);
  cLegOfferPx.mark = 0;
  cLegOfferPx.destroy = (void (*)(void *)) free_FIX_LegOfferPx;
  cLegOfferPx.trackObjects = 0;
  
  cLiquidityIndType.klass = rb_define_class_under(mQuickfix, "LiquidityIndType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityIndType, (void *) &cLiquidityIndType);
  rb_define_alloc_func(cLiquidityIndType.klass, _wrap_LiquidityIndType_allocate);
  rb_define_method(cLiquidityIndType.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityIndType), -1);
  cLiquidityIndType.mark = 0;
  cLiquidityIndType.destroy = (void (*)(void *)) free_FIX_LiquidityIndType;
  cLiquidityIndType.trackObjects = 0;
  
  cHopSendingTime.klass = rb_define_class_under(mQuickfix, "HopSendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HopSendingTime, (void *) &cHopSendingTime);
  rb_define_alloc_func(cHopSendingTime.klass, _wrap_HopSendingTime_allocate);
  rb_define_method(cHopSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_HopSendingTime), -1);
  cHopSendingTime.mark = 0;
  cHopSendingTime.destroy = (void (*)(void *)) free_FIX_HopSendingTime;
  cHopSendingTime.trackObjects = 0;
  
  cRelationshipRiskLimitAmount.klass = rb_define_class_under(mQuickfix, "RelationshipRiskLimitAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskLimitAmount, (void *) &cRelationshipRiskLimitAmount);
  rb_define_alloc_func(cRelationshipRiskLimitAmount.klass, _wrap_RelationshipRiskLimitAmount_allocate);
  rb_define_method(cRelationshipRiskLimitAmount.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskLimitAmount), -1);
  cRelationshipRiskLimitAmount.mark = 0;
  cRelationshipRiskLimitAmount.destroy = (void (*)(void *)) free_FIX_RelationshipRiskLimitAmount;
  cRelationshipRiskLimitAmount.trackObjects = 0;
  
  cApplResendFlag.klass = rb_define_class_under(mQuickfix, "ApplResendFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResendFlag, (void *) &cApplResendFlag);
  rb_define_alloc_func(cApplResendFlag.klass, _wrap_ApplResendFlag_allocate);
  rb_define_method(cApplResendFlag.klass, "initialize", VALUEFUNC(_wrap_new_ApplResendFlag), -1);
  cApplResendFlag.mark = 0;
  cApplResendFlag.destroy = (void (*)(void *)) free_FIX_ApplResendFlag;
  cApplResendFlag.trackObjects = 0;
  
  cDerivativeCapPrice.klass = rb_define_class_under(mQuickfix, "DerivativeCapPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeCapPrice, (void *) &cDerivativeCapPrice);
  rb_define_alloc_func(cDerivativeCapPrice.klass, _wrap_DerivativeCapPrice_allocate);
  rb_define_method(cDerivativeCapPrice.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeCapPrice), -1);
  cDerivativeCapPrice.mark = 0;
  cDerivativeCapPrice.destroy = (void (*)(void *)) free_FIX_DerivativeCapPrice;
  cDerivativeCapPrice.trackObjects = 0;
  
  cRiskSecurityID.klass = rb_define_class_under(mQuickfix, "RiskSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityID, (void *) &cRiskSecurityID);
  rb_define_alloc_func(cRiskSecurityID.klass, _wrap_RiskSecurityID_allocate);
  rb_define_method(cRiskSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityID), -1);
  cRiskSecurityID.mark = 0;
  cRiskSecurityID.destroy = (void (*)(void *)) free_FIX_RiskSecurityID;
  cRiskSecurityID.trackObjects = 0;
  
  cComplexOptPayoutAmount.klass = rb_define_class_under(mQuickfix, "ComplexOptPayoutAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexOptPayoutAmount, (void *) &cComplexOptPayoutAmount);
  rb_define_alloc_func(cComplexOptPayoutAmount.klass, _wrap_ComplexOptPayoutAmount_allocate);
  rb_define_method(cComplexOptPayoutAmount.klass, "initialize", VALUEFUNC(_wrap_new_ComplexOptPayoutAmount), -1);
  cComplexOptPayoutAmount.mark = 0;
  cComplexOptPayoutAmount.destroy = (void (*)(void *)) free_FIX_ComplexOptPayoutAmount;
  cComplexOptPayoutAmount.trackObjects = 0;
  
  cLanguageCode.klass = rb_define_class_under(mQuickfix, "LanguageCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LanguageCode, (void *) &cLanguageCode);
  rb_define_alloc_func(cLanguageCode.klass, _wrap_LanguageCode_allocate);
  rb_define_method(cLanguageCode.klass, "initialize", VALUEFUNC(_wrap_new_LanguageCode), -1);
  cLanguageCode.mark = 0;
  cLanguageCode.destroy = (void (*)(void *)) free_FIX_LanguageCode;
  cLanguageCode.trackObjects = 0;
  
  cSettlObligRefID.klass = rb_define_class_under(mQuickfix, "SettlObligRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligRefID, (void *) &cSettlObligRefID);
  rb_define_alloc_func(cSettlObligRefID.klass, _wrap_SettlObligRefID_allocate);
  rb_define_method(cSettlObligRefID.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligRefID), -1);
  cSettlObligRefID.mark = 0;
  cSettlObligRefID.destroy = (void (*)(void *)) free_FIX_SettlObligRefID;
  cSettlObligRefID.trackObjects = 0;
  
  cOrigTradeID.klass = rb_define_class_under(mQuickfix, "OrigTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigTradeID, (void *) &cOrigTradeID);
  rb_define_alloc_func(cOrigTradeID.klass, _wrap_OrigTradeID_allocate);
  rb_define_method(cOrigTradeID.klass, "initialize", VALUEFUNC(_wrap_new_OrigTradeID), -1);
  cOrigTradeID.mark = 0;
  cOrigTradeID.destroy = (void (*)(void *)) free_FIX_OrigTradeID;
  cOrigTradeID.trackObjects = 0;
  
  cUnderlyingCollectAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingCollectAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCollectAmount, (void *) &cUnderlyingCollectAmount);
  rb_define_alloc_func(cUnderlyingCollectAmount.klass, _wrap_UnderlyingCollectAmount_allocate);
  rb_define_method(cUnderlyingCollectAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCollectAmount), -1);
  cUnderlyingCollectAmount.mark = 0;
  cUnderlyingCollectAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingCollectAmount;
  cUnderlyingCollectAmount.trackObjects = 0;
  
  cStatusValue.klass = rb_define_class_under(mQuickfix, "StatusValue", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StatusValue, (void *) &cStatusValue);
  rb_define_alloc_func(cStatusValue.klass, _wrap_StatusValue_allocate);
  rb_define_method(cStatusValue.klass, "initialize", VALUEFUNC(_wrap_new_StatusValue), -1);
  cStatusValue.mark = 0;
  cStatusValue.destroy = (void (*)(void *)) free_FIX_StatusValue;
  cStatusValue.trackObjects = 0;
  
  cOfferSpotRate.klass = rb_define_class_under(mQuickfix, "OfferSpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OfferSpotRate, (void *) &cOfferSpotRate);
  rb_define_alloc_func(cOfferSpotRate.klass, _wrap_OfferSpotRate_allocate);
  rb_define_method(cOfferSpotRate.klass, "initialize", VALUEFUNC(_wrap_new_OfferSpotRate), -1);
  cOfferSpotRate.mark = 0;
  cOfferSpotRate.destroy = (void (*)(void *)) free_FIX_OfferSpotRate;
  cOfferSpotRate.trackObjects = 0;
  
  cPosType.klass = rb_define_class_under(mQuickfix, "PosType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosType, (void *) &cPosType);
  rb_define_alloc_func(cPosType.klass, _wrap_PosType_allocate);
  rb_define_method(cPosType.klass, "initialize", VALUEFUNC(_wrap_new_PosType), -1);
  cPosType.mark = 0;
  cPosType.destroy = (void (*)(void *)) free_FIX_PosType;
  cPosType.trackObjects = 0;
  
  cUnderlyingRedemptionDate.klass = rb_define_class_under(mQuickfix, "UnderlyingRedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRedemptionDate, (void *) &cUnderlyingRedemptionDate);
  rb_define_alloc_func(cUnderlyingRedemptionDate.klass, _wrap_UnderlyingRedemptionDate_allocate);
  rb_define_method(cUnderlyingRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRedemptionDate), -1);
  cUnderlyingRedemptionDate.mark = 0;
  cUnderlyingRedemptionDate.destroy = (void (*)(void *)) free_FIX_UnderlyingRedemptionDate;
  cUnderlyingRedemptionDate.trackObjects = 0;
  
  cSettlDepositoryCode.klass = rb_define_class_under(mQuickfix, "SettlDepositoryCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDepositoryCode, (void *) &cSettlDepositoryCode);
  rb_define_alloc_func(cSettlDepositoryCode.klass, _wrap_SettlDepositoryCode_allocate);
  rb_define_method(cSettlDepositoryCode.klass, "initialize", VALUEFUNC(_wrap_new_SettlDepositoryCode), -1);
  cSettlDepositoryCode.mark = 0;
  cSettlDepositoryCode.destroy = (void (*)(void *)) free_FIX_SettlDepositoryCode;
  cSettlDepositoryCode.trackObjects = 0;
  
  cStreamAsgnAckType.klass = rb_define_class_under(mQuickfix, "StreamAsgnAckType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StreamAsgnAckType, (void *) &cStreamAsgnAckType);
  rb_define_alloc_func(cStreamAsgnAckType.klass, _wrap_StreamAsgnAckType_allocate);
  rb_define_method(cStreamAsgnAckType.klass, "initialize", VALUEFUNC(_wrap_new_StreamAsgnAckType), -1);
  cStreamAsgnAckType.mark = 0;
  cStreamAsgnAckType.destroy = (void (*)(void *)) free_FIX_StreamAsgnAckType;
  cStreamAsgnAckType.trackObjects = 0;
  
  cFloorPrice.klass = rb_define_class_under(mQuickfix, "FloorPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FloorPrice, (void *) &cFloorPrice);
  rb_define_alloc_func(cFloorPrice.klass, _wrap_FloorPrice_allocate);
  rb_define_method(cFloorPrice.klass, "initialize", VALUEFUNC(_wrap_new_FloorPrice), -1);
  cFloorPrice.mark = 0;
  cFloorPrice.destroy = (void (*)(void *)) free_FIX_FloorPrice;
  cFloorPrice.trackObjects = 0;
  
  cRiskMaturityTime.klass = rb_define_class_under(mQuickfix, "RiskMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskMaturityTime, (void *) &cRiskMaturityTime);
  rb_define_alloc_func(cRiskMaturityTime.klass, _wrap_RiskMaturityTime_allocate);
  rb_define_method(cRiskMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_RiskMaturityTime), -1);
  cRiskMaturityTime.mark = 0;
  cRiskMaturityTime.destroy = (void (*)(void *)) free_FIX_RiskMaturityTime;
  cRiskMaturityTime.trackObjects = 0;
  
  cUnderlyingPriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "UnderlyingPriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty, (void *) &cUnderlyingPriceUnitOfMeasureQty);
  rb_define_alloc_func(cUnderlyingPriceUnitOfMeasureQty.klass, _wrap_UnderlyingPriceUnitOfMeasureQty_allocate);
  rb_define_method(cUnderlyingPriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPriceUnitOfMeasureQty), -1);
  cUnderlyingPriceUnitOfMeasureQty.mark = 0;
  cUnderlyingPriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_UnderlyingPriceUnitOfMeasureQty;
  cUnderlyingPriceUnitOfMeasureQty.trackObjects = 0;
  
  cFeeMultiplier.klass = rb_define_class_under(mQuickfix, "FeeMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FeeMultiplier, (void *) &cFeeMultiplier);
  rb_define_alloc_func(cFeeMultiplier.klass, _wrap_FeeMultiplier_allocate);
  rb_define_method(cFeeMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_FeeMultiplier), -1);
  cFeeMultiplier.mark = 0;
  cFeeMultiplier.destroy = (void (*)(void *)) free_FIX_FeeMultiplier;
  cFeeMultiplier.trackObjects = 0;
  
  cUnderlyingMaturityTime.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityTime, (void *) &cUnderlyingMaturityTime);
  rb_define_alloc_func(cUnderlyingMaturityTime.klass, _wrap_UnderlyingMaturityTime_allocate);
  rb_define_method(cUnderlyingMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityTime), -1);
  cUnderlyingMaturityTime.mark = 0;
  cUnderlyingMaturityTime.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityTime;
  cUnderlyingMaturityTime.trackObjects = 0;
  
  cApplID.klass = rb_define_class_under(mQuickfix, "ApplID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplID, (void *) &cApplID);
  rb_define_alloc_func(cApplID.klass, _wrap_ApplID_allocate);
  rb_define_method(cApplID.klass, "initialize", VALUEFUNC(_wrap_new_ApplID), -1);
  cApplID.mark = 0;
  cApplID.destroy = (void (*)(void *)) free_FIX_ApplID;
  cApplID.trackObjects = 0;
  
  cLegGrossTradeAmt.klass = rb_define_class_under(mQuickfix, "LegGrossTradeAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegGrossTradeAmt, (void *) &cLegGrossTradeAmt);
  rb_define_alloc_func(cLegGrossTradeAmt.klass, _wrap_LegGrossTradeAmt_allocate);
  rb_define_method(cLegGrossTradeAmt.klass, "initialize", VALUEFUNC(_wrap_new_LegGrossTradeAmt), -1);
  cLegGrossTradeAmt.mark = 0;
  cLegGrossTradeAmt.destroy = (void (*)(void *)) free_FIX_LegGrossTradeAmt;
  cLegGrossTradeAmt.trackObjects = 0;
  
  cMDEntryDate.klass = rb_define_class_under(mQuickfix, "MDEntryDate", ((swig_class *) SWIGTYPE_p_FIX__UtcDateField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryDate, (void *) &cMDEntryDate);
  rb_define_alloc_func(cMDEntryDate.klass, _wrap_MDEntryDate_allocate);
  rb_define_method(cMDEntryDate.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryDate), -1);
  cMDEntryDate.mark = 0;
  cMDEntryDate.destroy = (void (*)(void *)) free_FIX_MDEntryDate;
  cMDEntryDate.trackObjects = 0;
  
  cLegBenchmarkCurveCurrency.klass = rb_define_class_under(mQuickfix, "LegBenchmarkCurveCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency, (void *) &cLegBenchmarkCurveCurrency);
  rb_define_alloc_func(cLegBenchmarkCurveCurrency.klass, _wrap_LegBenchmarkCurveCurrency_allocate);
  rb_define_method(cLegBenchmarkCurveCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegBenchmarkCurveCurrency), -1);
  cLegBenchmarkCurveCurrency.mark = 0;
  cLegBenchmarkCurveCurrency.destroy = (void (*)(void *)) free_FIX_LegBenchmarkCurveCurrency;
  cLegBenchmarkCurveCurrency.trackObjects = 0;
  
  cRiskInstrumentOperator.klass = rb_define_class_under(mQuickfix, "RiskInstrumentOperator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskInstrumentOperator, (void *) &cRiskInstrumentOperator);
  rb_define_alloc_func(cRiskInstrumentOperator.klass, _wrap_RiskInstrumentOperator_allocate);
  rb_define_method(cRiskInstrumentOperator.klass, "initialize", VALUEFUNC(_wrap_new_RiskInstrumentOperator), -1);
  cRiskInstrumentOperator.mark = 0;
  cRiskInstrumentOperator.destroy = (void (*)(void *)) free_FIX_RiskInstrumentOperator;
  cRiskInstrumentOperator.trackObjects = 0;
  
  cOptPayoutAmount.klass = rb_define_class_under(mQuickfix, "OptPayoutAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptPayoutAmount, (void *) &cOptPayoutAmount);
  rb_define_alloc_func(cOptPayoutAmount.klass, _wrap_OptPayoutAmount_allocate);
  rb_define_method(cOptPayoutAmount.klass, "initialize", VALUEFUNC(_wrap_new_OptPayoutAmount), -1);
  cOptPayoutAmount.mark = 0;
  cOptPayoutAmount.destroy = (void (*)(void *)) free_FIX_OptPayoutAmount;
  cOptPayoutAmount.trackObjects = 0;
  
  cMiscFeeBasis.klass = rb_define_class_under(mQuickfix, "MiscFeeBasis", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MiscFeeBasis, (void *) &cMiscFeeBasis);
  rb_define_alloc_func(cMiscFeeBasis.klass, _wrap_MiscFeeBasis_allocate);
  rb_define_method(cMiscFeeBasis.klass, "initialize", VALUEFUNC(_wrap_new_MiscFeeBasis), -1);
  cMiscFeeBasis.mark = 0;
  cMiscFeeBasis.destroy = (void (*)(void *)) free_FIX_MiscFeeBasis;
  cMiscFeeBasis.trackObjects = 0;
  
  cValidUntilTime.klass = rb_define_class_under(mQuickfix, "ValidUntilTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ValidUntilTime, (void *) &cValidUntilTime);
  rb_define_alloc_func(cValidUntilTime.klass, _wrap_ValidUntilTime_allocate);
  rb_define_method(cValidUntilTime.klass, "initialize", VALUEFUNC(_wrap_new_ValidUntilTime), -1);
  cValidUntilTime.mark = 0;
  cValidUntilTime.destroy = (void (*)(void *)) free_FIX_ValidUntilTime;
  cValidUntilTime.trackObjects = 0;
  
  cOrdType.klass = rb_define_class_under(mQuickfix, "OrdType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrdType, (void *) &cOrdType);
  rb_define_alloc_func(cOrdType.klass, _wrap_OrdType_allocate);
  rb_define_method(cOrdType.klass, "initialize", VALUEFUNC(_wrap_new_OrdType), -1);
  cOrdType.mark = 0;
  cOrdType.destroy = (void (*)(void *)) free_FIX_OrdType;
  cOrdType.trackObjects = 0;
  
  cAdvRefID.klass = rb_define_class_under(mQuickfix, "AdvRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AdvRefID, (void *) &cAdvRefID);
  rb_define_alloc_func(cAdvRefID.klass, _wrap_AdvRefID_allocate);
  rb_define_method(cAdvRefID.klass, "initialize", VALUEFUNC(_wrap_new_AdvRefID), -1);
  cAdvRefID.mark = 0;
  cAdvRefID.destroy = (void (*)(void *)) free_FIX_AdvRefID;
  cAdvRefID.trackObjects = 0;
  
  cHopCompID.klass = rb_define_class_under(mQuickfix, "HopCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__HopCompID, (void *) &cHopCompID);
  rb_define_alloc_func(cHopCompID.klass, _wrap_HopCompID_allocate);
  rb_define_method(cHopCompID.klass, "initialize", VALUEFUNC(_wrap_new_HopCompID), -1);
  cHopCompID.mark = 0;
  cHopCompID.destroy = (void (*)(void *)) free_FIX_HopCompID;
  cHopCompID.trackObjects = 0;
  
  cPosMaintRptRefID.klass = rb_define_class_under(mQuickfix, "PosMaintRptRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintRptRefID, (void *) &cPosMaintRptRefID);
  rb_define_alloc_func(cPosMaintRptRefID.klass, _wrap_PosMaintRptRefID_allocate);
  rb_define_method(cPosMaintRptRefID.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintRptRefID), -1);
  cPosMaintRptRefID.mark = 0;
  cPosMaintRptRefID.destroy = (void (*)(void *)) free_FIX_PosMaintRptRefID;
  cPosMaintRptRefID.trackObjects = 0;
  
  cLegStipulationValue.klass = rb_define_class_under(mQuickfix, "LegStipulationValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStipulationValue, (void *) &cLegStipulationValue);
  rb_define_alloc_func(cLegStipulationValue.klass, _wrap_LegStipulationValue_allocate);
  rb_define_method(cLegStipulationValue.klass, "initialize", VALUEFUNC(_wrap_new_LegStipulationValue), -1);
  cLegStipulationValue.mark = 0;
  cLegStipulationValue.destroy = (void (*)(void *)) free_FIX_LegStipulationValue;
  cLegStipulationValue.trackObjects = 0;
  
  cMatchType.klass = rb_define_class_under(mQuickfix, "MatchType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchType, (void *) &cMatchType);
  rb_define_alloc_func(cMatchType.klass, _wrap_MatchType_allocate);
  rb_define_method(cMatchType.klass, "initialize", VALUEFUNC(_wrap_new_MatchType), -1);
  cMatchType.mark = 0;
  cMatchType.destroy = (void (*)(void *)) free_FIX_MatchType;
  cMatchType.trackObjects = 0;
  
  cOptPayoutType.klass = rb_define_class_under(mQuickfix, "OptPayoutType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptPayoutType, (void *) &cOptPayoutType);
  rb_define_alloc_func(cOptPayoutType.klass, _wrap_OptPayoutType_allocate);
  rb_define_method(cOptPayoutType.klass, "initialize", VALUEFUNC(_wrap_new_OptPayoutType), -1);
  cOptPayoutType.mark = 0;
  cOptPayoutType.destroy = (void (*)(void *)) free_FIX_OptPayoutType;
  cOptPayoutType.trackObjects = 0;
  
  cUnderlyingPriceUnitOfMeasure.klass = rb_define_class_under(mQuickfix, "UnderlyingPriceUnitOfMeasure", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure, (void *) &cUnderlyingPriceUnitOfMeasure);
  rb_define_alloc_func(cUnderlyingPriceUnitOfMeasure.klass, _wrap_UnderlyingPriceUnitOfMeasure_allocate);
  rb_define_method(cUnderlyingPriceUnitOfMeasure.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPriceUnitOfMeasure), -1);
  cUnderlyingPriceUnitOfMeasure.mark = 0;
  cUnderlyingPriceUnitOfMeasure.destroy = (void (*)(void *)) free_FIX_UnderlyingPriceUnitOfMeasure;
  cUnderlyingPriceUnitOfMeasure.trackObjects = 0;
  
  cMarketUpdateAction.klass = rb_define_class_under(mQuickfix, "MarketUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarketUpdateAction, (void *) &cMarketUpdateAction);
  rb_define_alloc_func(cMarketUpdateAction.klass, _wrap_MarketUpdateAction_allocate);
  rb_define_method(cMarketUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_MarketUpdateAction), -1);
  cMarketUpdateAction.mark = 0;
  cMarketUpdateAction.destroy = (void (*)(void *)) free_FIX_MarketUpdateAction;
  cMarketUpdateAction.trackObjects = 0;
  
  cCollAsgnRejectReason.klass = rb_define_class_under(mQuickfix, "CollAsgnRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnRejectReason, (void *) &cCollAsgnRejectReason);
  rb_define_alloc_func(cCollAsgnRejectReason.klass, _wrap_CollAsgnRejectReason_allocate);
  rb_define_method(cCollAsgnRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnRejectReason), -1);
  cCollAsgnRejectReason.mark = 0;
  cCollAsgnRejectReason.destroy = (void (*)(void *)) free_FIX_CollAsgnRejectReason;
  cCollAsgnRejectReason.trackObjects = 0;
  
  cPeggedRefPrice.klass = rb_define_class_under(mQuickfix, "PeggedRefPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PeggedRefPrice, (void *) &cPeggedRefPrice);
  rb_define_alloc_func(cPeggedRefPrice.klass, _wrap_PeggedRefPrice_allocate);
  rb_define_method(cPeggedRefPrice.klass, "initialize", VALUEFUNC(_wrap_new_PeggedRefPrice), -1);
  cPeggedRefPrice.mark = 0;
  cPeggedRefPrice.destroy = (void (*)(void *)) free_FIX_PeggedRefPrice;
  cPeggedRefPrice.trackObjects = 0;
  
  cIndividualAllocType.klass = rb_define_class_under(mQuickfix, "IndividualAllocType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IndividualAllocType, (void *) &cIndividualAllocType);
  rb_define_alloc_func(cIndividualAllocType.klass, _wrap_IndividualAllocType_allocate);
  rb_define_method(cIndividualAllocType.klass, "initialize", VALUEFUNC(_wrap_new_IndividualAllocType), -1);
  cIndividualAllocType.mark = 0;
  cIndividualAllocType.destroy = (void (*)(void *)) free_FIX_IndividualAllocType;
  cIndividualAllocType.trackObjects = 0;
  
  cEndCash.klass = rb_define_class_under(mQuickfix, "EndCash", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndCash, (void *) &cEndCash);
  rb_define_alloc_func(cEndCash.klass, _wrap_EndCash_allocate);
  rb_define_method(cEndCash.klass, "initialize", VALUEFUNC(_wrap_new_EndCash), -1);
  cEndCash.mark = 0;
  cEndCash.destroy = (void (*)(void *)) free_FIX_EndCash;
  cEndCash.trackObjects = 0;
  
  cEventText.klass = rb_define_class_under(mQuickfix, "EventText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EventText, (void *) &cEventText);
  rb_define_alloc_func(cEventText.klass, _wrap_EventText_allocate);
  rb_define_method(cEventText.klass, "initialize", VALUEFUNC(_wrap_new_EventText), -1);
  cEventText.mark = 0;
  cEventText.destroy = (void (*)(void *)) free_FIX_EventText;
  cEventText.trackObjects = 0;
  
  cExDate.klass = rb_define_class_under(mQuickfix, "ExDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExDate, (void *) &cExDate);
  rb_define_alloc_func(cExDate.klass, _wrap_ExDate_allocate);
  rb_define_method(cExDate.klass, "initialize", VALUEFUNC(_wrap_new_ExDate), -1);
  cExDate.mark = 0;
  cExDate.destroy = (void (*)(void *)) free_FIX_ExDate;
  cExDate.trackObjects = 0;
  
  cNestedPartyIDSource.klass = rb_define_class_under(mQuickfix, "NestedPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedPartyIDSource, (void *) &cNestedPartyIDSource);
  rb_define_alloc_func(cNestedPartyIDSource.klass, _wrap_NestedPartyIDSource_allocate);
  rb_define_method(cNestedPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_NestedPartyIDSource), -1);
  cNestedPartyIDSource.mark = 0;
  cNestedPartyIDSource.destroy = (void (*)(void *)) free_FIX_NestedPartyIDSource;
  cNestedPartyIDSource.trackObjects = 0;
  
  cGTBookingInst.klass = rb_define_class_under(mQuickfix, "GTBookingInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__GTBookingInst, (void *) &cGTBookingInst);
  rb_define_alloc_func(cGTBookingInst.klass, _wrap_GTBookingInst_allocate);
  rb_define_method(cGTBookingInst.klass, "initialize", VALUEFUNC(_wrap_new_GTBookingInst), -1);
  cGTBookingInst.mark = 0;
  cGTBookingInst.destroy = (void (*)(void *)) free_FIX_GTBookingInst;
  cGTBookingInst.trackObjects = 0;
  
  cDerivativeValuationMethod.klass = rb_define_class_under(mQuickfix, "DerivativeValuationMethod", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeValuationMethod, (void *) &cDerivativeValuationMethod);
  rb_define_alloc_func(cDerivativeValuationMethod.klass, _wrap_DerivativeValuationMethod_allocate);
  rb_define_method(cDerivativeValuationMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeValuationMethod), -1);
  cDerivativeValuationMethod.mark = 0;
  cDerivativeValuationMethod.destroy = (void (*)(void *)) free_FIX_DerivativeValuationMethod;
  cDerivativeValuationMethod.trackObjects = 0;
  
  cNumberOfOrders.klass = rb_define_class_under(mQuickfix, "NumberOfOrders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumberOfOrders, (void *) &cNumberOfOrders);
  rb_define_alloc_func(cNumberOfOrders.klass, _wrap_NumberOfOrders_allocate);
  rb_define_method(cNumberOfOrders.klass, "initialize", VALUEFUNC(_wrap_new_NumberOfOrders), -1);
  cNumberOfOrders.mark = 0;
  cNumberOfOrders.destroy = (void (*)(void *)) free_FIX_NumberOfOrders;
  cNumberOfOrders.trackObjects = 0;
  
  cTrdRepPartyRole.klass = rb_define_class_under(mQuickfix, "TrdRepPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRepPartyRole, (void *) &cTrdRepPartyRole);
  rb_define_alloc_func(cTrdRepPartyRole.klass, _wrap_TrdRepPartyRole_allocate);
  rb_define_method(cTrdRepPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_TrdRepPartyRole), -1);
  cTrdRepPartyRole.mark = 0;
  cTrdRepPartyRole.destroy = (void (*)(void *)) free_FIX_TrdRepPartyRole;
  cTrdRepPartyRole.trackObjects = 0;
  
  cTriggerPrice.klass = rb_define_class_under(mQuickfix, "TriggerPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerPrice, (void *) &cTriggerPrice);
  rb_define_alloc_func(cTriggerPrice.klass, _wrap_TriggerPrice_allocate);
  rb_define_method(cTriggerPrice.klass, "initialize", VALUEFUNC(_wrap_new_TriggerPrice), -1);
  cTriggerPrice.mark = 0;
  cTriggerPrice.destroy = (void (*)(void *)) free_FIX_TriggerPrice;
  cTriggerPrice.trackObjects = 0;
  
  cMDReportID.klass = rb_define_class_under(mQuickfix, "MDReportID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDReportID, (void *) &cMDReportID);
  rb_define_alloc_func(cMDReportID.klass, _wrap_MDReportID_allocate);
  rb_define_method(cMDReportID.klass, "initialize", VALUEFUNC(_wrap_new_MDReportID), -1);
  cMDReportID.mark = 0;
  cMDReportID.destroy = (void (*)(void *)) free_FIX_MDReportID;
  cMDReportID.trackObjects = 0;
  
  cSecondaryAllocID.klass = rb_define_class_under(mQuickfix, "SecondaryAllocID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryAllocID, (void *) &cSecondaryAllocID);
  rb_define_alloc_func(cSecondaryAllocID.klass, _wrap_SecondaryAllocID_allocate);
  rb_define_method(cSecondaryAllocID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryAllocID), -1);
  cSecondaryAllocID.mark = 0;
  cSecondaryAllocID.destroy = (void (*)(void *)) free_FIX_SecondaryAllocID;
  cSecondaryAllocID.trackObjects = 0;
  
  cLeavesQty.klass = rb_define_class_under(mQuickfix, "LeavesQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LeavesQty, (void *) &cLeavesQty);
  rb_define_alloc_func(cLeavesQty.klass, _wrap_LeavesQty_allocate);
  rb_define_method(cLeavesQty.klass, "initialize", VALUEFUNC(_wrap_new_LeavesQty), -1);
  cLeavesQty.mark = 0;
  cLeavesQty.destroy = (void (*)(void *)) free_FIX_LeavesQty;
  cLeavesQty.trackObjects = 0;
  
  cCardStartDate.klass = rb_define_class_under(mQuickfix, "CardStartDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CardStartDate, (void *) &cCardStartDate);
  rb_define_alloc_func(cCardStartDate.klass, _wrap_CardStartDate_allocate);
  rb_define_method(cCardStartDate.klass, "initialize", VALUEFUNC(_wrap_new_CardStartDate), -1);
  cCardStartDate.mark = 0;
  cCardStartDate.destroy = (void (*)(void *)) free_FIX_CardStartDate;
  cCardStartDate.trackObjects = 0;
  
  cLegCoveredOrUncovered.klass = rb_define_class_under(mQuickfix, "LegCoveredOrUncovered", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCoveredOrUncovered, (void *) &cLegCoveredOrUncovered);
  rb_define_alloc_func(cLegCoveredOrUncovered.klass, _wrap_LegCoveredOrUncovered_allocate);
  rb_define_method(cLegCoveredOrUncovered.klass, "initialize", VALUEFUNC(_wrap_new_LegCoveredOrUncovered), -1);
  cLegCoveredOrUncovered.mark = 0;
  cLegCoveredOrUncovered.destroy = (void (*)(void *)) free_FIX_LegCoveredOrUncovered;
  cLegCoveredOrUncovered.trackObjects = 0;
  
  cPutOrCall.klass = rb_define_class_under(mQuickfix, "PutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PutOrCall, (void *) &cPutOrCall);
  rb_define_alloc_func(cPutOrCall.klass, _wrap_PutOrCall_allocate);
  rb_define_method(cPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_PutOrCall), -1);
  cPutOrCall.mark = 0;
  cPutOrCall.destroy = (void (*)(void *)) free_FIX_PutOrCall;
  cPutOrCall.trackObjects = 0;
  
  cMatchAlgorithm.klass = rb_define_class_under(mQuickfix, "MatchAlgorithm", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchAlgorithm, (void *) &cMatchAlgorithm);
  rb_define_alloc_func(cMatchAlgorithm.klass, _wrap_MatchAlgorithm_allocate);
  rb_define_method(cMatchAlgorithm.klass, "initialize", VALUEFUNC(_wrap_new_MatchAlgorithm), -1);
  cMatchAlgorithm.mark = 0;
  cMatchAlgorithm.destroy = (void (*)(void *)) free_FIX_MatchAlgorithm;
  cMatchAlgorithm.trackObjects = 0;
  
  cCalculatedCcyLastQty.klass = rb_define_class_under(mQuickfix, "CalculatedCcyLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CalculatedCcyLastQty, (void *) &cCalculatedCcyLastQty);
  rb_define_alloc_func(cCalculatedCcyLastQty.klass, _wrap_CalculatedCcyLastQty_allocate);
  rb_define_method(cCalculatedCcyLastQty.klass, "initialize", VALUEFUNC(_wrap_new_CalculatedCcyLastQty), -1);
  cCalculatedCcyLastQty.mark = 0;
  cCalculatedCcyLastQty.destroy = (void (*)(void *)) free_FIX_CalculatedCcyLastQty;
  cCalculatedCcyLastQty.trackObjects = 0;
  
  cFundRenewWaiv.klass = rb_define_class_under(mQuickfix, "FundRenewWaiv", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FundRenewWaiv, (void *) &cFundRenewWaiv);
  rb_define_alloc_func(cFundRenewWaiv.klass, _wrap_FundRenewWaiv_allocate);
  rb_define_method(cFundRenewWaiv.klass, "initialize", VALUEFUNC(_wrap_new_FundRenewWaiv), -1);
  cFundRenewWaiv.mark = 0;
  cFundRenewWaiv.destroy = (void (*)(void *)) free_FIX_FundRenewWaiv;
  cFundRenewWaiv.trackObjects = 0;
  
  cSecuritySettlAgentName.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentName, (void *) &cSecuritySettlAgentName);
  rb_define_alloc_func(cSecuritySettlAgentName.klass, _wrap_SecuritySettlAgentName_allocate);
  rb_define_method(cSecuritySettlAgentName.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentName), -1);
  cSecuritySettlAgentName.mark = 0;
  cSecuritySettlAgentName.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentName;
  cSecuritySettlAgentName.trackObjects = 0;
  
  cBidDescriptor.klass = rb_define_class_under(mQuickfix, "BidDescriptor", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidDescriptor, (void *) &cBidDescriptor);
  rb_define_alloc_func(cBidDescriptor.klass, _wrap_BidDescriptor_allocate);
  rb_define_method(cBidDescriptor.klass, "initialize", VALUEFUNC(_wrap_new_BidDescriptor), -1);
  cBidDescriptor.mark = 0;
  cBidDescriptor.destroy = (void (*)(void *)) free_FIX_BidDescriptor;
  cBidDescriptor.trackObjects = 0;
  
  cRelationshipRiskSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityAltIDSource, (void *) &cRelationshipRiskSecurityAltIDSource);
  rb_define_alloc_func(cRelationshipRiskSecurityAltIDSource.klass, _wrap_RelationshipRiskSecurityAltIDSource_allocate);
  rb_define_method(cRelationshipRiskSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityAltIDSource), -1);
  cRelationshipRiskSecurityAltIDSource.mark = 0;
  cRelationshipRiskSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityAltIDSource;
  cRelationshipRiskSecurityAltIDSource.trackObjects = 0;
  
  cMDStreamID.klass = rb_define_class_under(mQuickfix, "MDStreamID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDStreamID, (void *) &cMDStreamID);
  rb_define_alloc_func(cMDStreamID.klass, _wrap_MDStreamID_allocate);
  rb_define_method(cMDStreamID.klass, "initialize", VALUEFUNC(_wrap_new_MDStreamID), -1);
  cMDStreamID.mark = 0;
  cMDStreamID.destroy = (void (*)(void *)) free_FIX_MDStreamID;
  cMDStreamID.trackObjects = 0;
  
  cNoAsgnReqs.klass = rb_define_class_under(mQuickfix, "NoAsgnReqs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAsgnReqs, (void *) &cNoAsgnReqs);
  rb_define_alloc_func(cNoAsgnReqs.klass, _wrap_NoAsgnReqs_allocate);
  rb_define_method(cNoAsgnReqs.klass, "initialize", VALUEFUNC(_wrap_new_NoAsgnReqs), -1);
  cNoAsgnReqs.mark = 0;
  cNoAsgnReqs.destroy = (void (*)(void *)) free_FIX_NoAsgnReqs;
  cNoAsgnReqs.trackObjects = 0;
  
  cNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "NotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotionalPercentageOutstanding, (void *) &cNotionalPercentageOutstanding);
  rb_define_alloc_func(cNotionalPercentageOutstanding.klass, _wrap_NotionalPercentageOutstanding_allocate);
  rb_define_method(cNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_NotionalPercentageOutstanding), -1);
  cNotionalPercentageOutstanding.mark = 0;
  cNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_NotionalPercentageOutstanding;
  cNotionalPercentageOutstanding.trackObjects = 0;
  
  cNoSettlInst.klass = rb_define_class_under(mQuickfix, "NoSettlInst", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlInst, (void *) &cNoSettlInst);
  rb_define_alloc_func(cNoSettlInst.klass, _wrap_NoSettlInst_allocate);
  rb_define_method(cNoSettlInst.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlInst), -1);
  cNoSettlInst.mark = 0;
  cNoSettlInst.destroy = (void (*)(void *)) free_FIX_NoSettlInst;
  cNoSettlInst.trackObjects = 0;
  
  cSettlInstMsgID.klass = rb_define_class_under(mQuickfix, "SettlInstMsgID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlInstMsgID, (void *) &cSettlInstMsgID);
  rb_define_alloc_func(cSettlInstMsgID.klass, _wrap_SettlInstMsgID_allocate);
  rb_define_method(cSettlInstMsgID.klass, "initialize", VALUEFUNC(_wrap_new_SettlInstMsgID), -1);
  cSettlInstMsgID.mark = 0;
  cSettlInstMsgID.destroy = (void (*)(void *)) free_FIX_SettlInstMsgID;
  cSettlInstMsgID.trackObjects = 0;
  
  cForexReq.klass = rb_define_class_under(mQuickfix, "ForexReq", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ForexReq, (void *) &cForexReq);
  rb_define_alloc_func(cForexReq.klass, _wrap_ForexReq_allocate);
  rb_define_method(cForexReq.klass, "initialize", VALUEFUNC(_wrap_new_ForexReq), -1);
  cForexReq.mark = 0;
  cForexReq.destroy = (void (*)(void *)) free_FIX_ForexReq;
  cForexReq.trackObjects = 0;
  
  cTradSesReqID.klass = rb_define_class_under(mQuickfix, "TradSesReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesReqID, (void *) &cTradSesReqID);
  rb_define_alloc_func(cTradSesReqID.klass, _wrap_TradSesReqID_allocate);
  rb_define_method(cTradSesReqID.klass, "initialize", VALUEFUNC(_wrap_new_TradSesReqID), -1);
  cTradSesReqID.mark = 0;
  cTradSesReqID.destroy = (void (*)(void *)) free_FIX_TradSesReqID;
  cTradSesReqID.trackObjects = 0;
  
  cUnderlyingLegStrikePrice.klass = rb_define_class_under(mQuickfix, "UnderlyingLegStrikePrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegStrikePrice, (void *) &cUnderlyingLegStrikePrice);
  rb_define_alloc_func(cUnderlyingLegStrikePrice.klass, _wrap_UnderlyingLegStrikePrice_allocate);
  rb_define_method(cUnderlyingLegStrikePrice.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegStrikePrice), -1);
  cUnderlyingLegStrikePrice.mark = 0;
  cUnderlyingLegStrikePrice.destroy = (void (*)(void *)) free_FIX_UnderlyingLegStrikePrice;
  cUnderlyingLegStrikePrice.trackObjects = 0;
  
  cTickRuleType.klass = rb_define_class_under(mQuickfix, "TickRuleType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TickRuleType, (void *) &cTickRuleType);
  rb_define_alloc_func(cTickRuleType.klass, _wrap_TickRuleType_allocate);
  rb_define_method(cTickRuleType.klass, "initialize", VALUEFUNC(_wrap_new_TickRuleType), -1);
  cTickRuleType.mark = 0;
  cTickRuleType.destroy = (void (*)(void *)) free_FIX_TickRuleType;
  cTickRuleType.trackObjects = 0;
  
  cInstrmtAssignmentMethod.klass = rb_define_class_under(mQuickfix, "InstrmtAssignmentMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrmtAssignmentMethod, (void *) &cInstrmtAssignmentMethod);
  rb_define_alloc_func(cInstrmtAssignmentMethod.klass, _wrap_InstrmtAssignmentMethod_allocate);
  rb_define_method(cInstrmtAssignmentMethod.klass, "initialize", VALUEFUNC(_wrap_new_InstrmtAssignmentMethod), -1);
  cInstrmtAssignmentMethod.mark = 0;
  cInstrmtAssignmentMethod.destroy = (void (*)(void *)) free_FIX_InstrmtAssignmentMethod;
  cInstrmtAssignmentMethod.trackObjects = 0;
  
  cDiscretionOffsetType.klass = rb_define_class_under(mQuickfix, "DiscretionOffsetType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionOffsetType, (void *) &cDiscretionOffsetType);
  rb_define_alloc_func(cDiscretionOffsetType.klass, _wrap_DiscretionOffsetType_allocate);
  rb_define_method(cDiscretionOffsetType.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionOffsetType), -1);
  cDiscretionOffsetType.mark = 0;
  cDiscretionOffsetType.destroy = (void (*)(void *)) free_FIX_DiscretionOffsetType;
  cDiscretionOffsetType.trackObjects = 0;
  
  cConfirmTransType.klass = rb_define_class_under(mQuickfix, "ConfirmTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ConfirmTransType, (void *) &cConfirmTransType);
  rb_define_alloc_func(cConfirmTransType.klass, _wrap_ConfirmTransType_allocate);
  rb_define_method(cConfirmTransType.klass, "initialize", VALUEFUNC(_wrap_new_ConfirmTransType), -1);
  cConfirmTransType.mark = 0;
  cConfirmTransType.destroy = (void (*)(void *)) free_FIX_ConfirmTransType;
  cConfirmTransType.trackObjects = 0;
  
  cTotalTakedown.klass = rb_define_class_under(mQuickfix, "TotalTakedown", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalTakedown, (void *) &cTotalTakedown);
  rb_define_alloc_func(cTotalTakedown.klass, _wrap_TotalTakedown_allocate);
  rb_define_method(cTotalTakedown.klass, "initialize", VALUEFUNC(_wrap_new_TotalTakedown), -1);
  cTotalTakedown.mark = 0;
  cTotalTakedown.destroy = (void (*)(void *)) free_FIX_TotalTakedown;
  cTotalTakedown.trackObjects = 0;
  
  cResponseDestination.klass = rb_define_class_under(mQuickfix, "ResponseDestination", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ResponseDestination, (void *) &cResponseDestination);
  rb_define_alloc_func(cResponseDestination.klass, _wrap_ResponseDestination_allocate);
  rb_define_method(cResponseDestination.klass, "initialize", VALUEFUNC(_wrap_new_ResponseDestination), -1);
  cResponseDestination.mark = 0;
  cResponseDestination.destroy = (void (*)(void *)) free_FIX_ResponseDestination;
  cResponseDestination.trackObjects = 0;
  
  cMDSecSizeType.klass = rb_define_class_under(mQuickfix, "MDSecSizeType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDSecSizeType, (void *) &cMDSecSizeType);
  rb_define_alloc_func(cMDSecSizeType.klass, _wrap_MDSecSizeType_allocate);
  rb_define_method(cMDSecSizeType.klass, "initialize", VALUEFUNC(_wrap_new_MDSecSizeType), -1);
  cMDSecSizeType.mark = 0;
  cMDSecSizeType.destroy = (void (*)(void *)) free_FIX_MDSecSizeType;
  cMDSecSizeType.trackObjects = 0;
  
  cInstrumentPartySubIDType.klass = rb_define_class_under(mQuickfix, "InstrumentPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartySubIDType, (void *) &cInstrumentPartySubIDType);
  rb_define_alloc_func(cInstrumentPartySubIDType.klass, _wrap_InstrumentPartySubIDType_allocate);
  rb_define_method(cInstrumentPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartySubIDType), -1);
  cInstrumentPartySubIDType.mark = 0;
  cInstrumentPartySubIDType.destroy = (void (*)(void *)) free_FIX_InstrumentPartySubIDType;
  cInstrumentPartySubIDType.trackObjects = 0;
  
  cLegTimeUnit.klass = rb_define_class_under(mQuickfix, "LegTimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegTimeUnit, (void *) &cLegTimeUnit);
  rb_define_alloc_func(cLegTimeUnit.klass, _wrap_LegTimeUnit_allocate);
  rb_define_method(cLegTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_LegTimeUnit), -1);
  cLegTimeUnit.mark = 0;
  cLegTimeUnit.destroy = (void (*)(void *)) free_FIX_LegTimeUnit;
  cLegTimeUnit.trackObjects = 0;
  
  cTransferReason.klass = rb_define_class_under(mQuickfix, "TransferReason", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TransferReason, (void *) &cTransferReason);
  rb_define_alloc_func(cTransferReason.klass, _wrap_TransferReason_allocate);
  rb_define_method(cTransferReason.klass, "initialize", VALUEFUNC(_wrap_new_TransferReason), -1);
  cTransferReason.mark = 0;
  cTransferReason.destroy = (void (*)(void *)) free_FIX_TransferReason;
  cTransferReason.trackObjects = 0;
  
  cApplQueueMax.klass = rb_define_class_under(mQuickfix, "ApplQueueMax", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueMax, (void *) &cApplQueueMax);
  rb_define_alloc_func(cApplQueueMax.klass, _wrap_ApplQueueMax_allocate);
  rb_define_method(cApplQueueMax.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueMax), -1);
  cApplQueueMax.mark = 0;
  cApplQueueMax.destroy = (void (*)(void *)) free_FIX_ApplQueueMax;
  cApplQueueMax.trackObjects = 0;
  
  cDiscretionOffsetValue.klass = rb_define_class_under(mQuickfix, "DiscretionOffsetValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionOffsetValue, (void *) &cDiscretionOffsetValue);
  rb_define_alloc_func(cDiscretionOffsetValue.klass, _wrap_DiscretionOffsetValue_allocate);
  rb_define_method(cDiscretionOffsetValue.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionOffsetValue), -1);
  cDiscretionOffsetValue.mark = 0;
  cDiscretionOffsetValue.destroy = (void (*)(void *)) free_FIX_DiscretionOffsetValue;
  cDiscretionOffsetValue.trackObjects = 0;
  
  cBookingRefID.klass = rb_define_class_under(mQuickfix, "BookingRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BookingRefID, (void *) &cBookingRefID);
  rb_define_alloc_func(cBookingRefID.klass, _wrap_BookingRefID_allocate);
  rb_define_method(cBookingRefID.klass, "initialize", VALUEFUNC(_wrap_new_BookingRefID), -1);
  cBookingRefID.mark = 0;
  cBookingRefID.destroy = (void (*)(void *)) free_FIX_BookingRefID;
  cBookingRefID.trackObjects = 0;
  
  cLegBidPx.klass = rb_define_class_under(mQuickfix, "LegBidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBidPx, (void *) &cLegBidPx);
  rb_define_alloc_func(cLegBidPx.klass, _wrap_LegBidPx_allocate);
  rb_define_method(cLegBidPx.klass, "initialize", VALUEFUNC(_wrap_new_LegBidPx), -1);
  cLegBidPx.mark = 0;
  cLegBidPx.destroy = (void (*)(void *)) free_FIX_LegBidPx;
  cLegBidPx.trackObjects = 0;
  
  cContextPartyRole.klass = rb_define_class_under(mQuickfix, "ContextPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContextPartyRole, (void *) &cContextPartyRole);
  rb_define_alloc_func(cContextPartyRole.klass, _wrap_ContextPartyRole_allocate);
  rb_define_method(cContextPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_ContextPartyRole), -1);
  cContextPartyRole.mark = 0;
  cContextPartyRole.destroy = (void (*)(void *)) free_FIX_ContextPartyRole;
  cContextPartyRole.trackObjects = 0;
  
  cTradSesEvent.klass = rb_define_class_under(mQuickfix, "TradSesEvent", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesEvent, (void *) &cTradSesEvent);
  rb_define_alloc_func(cTradSesEvent.klass, _wrap_TradSesEvent_allocate);
  rb_define_method(cTradSesEvent.klass, "initialize", VALUEFUNC(_wrap_new_TradSesEvent), -1);
  cTradSesEvent.mark = 0;
  cTradSesEvent.destroy = (void (*)(void *)) free_FIX_TradSesEvent;
  cTradSesEvent.trackObjects = 0;
  
  cDerivativeProduct.klass = rb_define_class_under(mQuickfix, "DerivativeProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeProduct, (void *) &cDerivativeProduct);
  rb_define_alloc_func(cDerivativeProduct.klass, _wrap_DerivativeProduct_allocate);
  rb_define_method(cDerivativeProduct.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeProduct), -1);
  cDerivativeProduct.mark = 0;
  cDerivativeProduct.destroy = (void (*)(void *)) free_FIX_DerivativeProduct;
  cDerivativeProduct.trackObjects = 0;
  
  cRootPartyRole.klass = rb_define_class_under(mQuickfix, "RootPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartyRole, (void *) &cRootPartyRole);
  rb_define_alloc_func(cRootPartyRole.klass, _wrap_RootPartyRole_allocate);
  rb_define_method(cRootPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_RootPartyRole), -1);
  cRootPartyRole.mark = 0;
  cRootPartyRole.destroy = (void (*)(void *)) free_FIX_RootPartyRole;
  cRootPartyRole.trackObjects = 0;
  
  cDlvyInstType.klass = rb_define_class_under(mQuickfix, "DlvyInstType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DlvyInstType, (void *) &cDlvyInstType);
  rb_define_alloc_func(cDlvyInstType.klass, _wrap_DlvyInstType_allocate);
  rb_define_method(cDlvyInstType.klass, "initialize", VALUEFUNC(_wrap_new_DlvyInstType), -1);
  cDlvyInstType.mark = 0;
  cDlvyInstType.destroy = (void (*)(void *)) free_FIX_DlvyInstType;
  cDlvyInstType.trackObjects = 0;
  
  cNoLinesOfText.klass = rb_define_class_under(mQuickfix, "NoLinesOfText", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoLinesOfText, (void *) &cNoLinesOfText);
  rb_define_alloc_func(cNoLinesOfText.klass, _wrap_NoLinesOfText_allocate);
  rb_define_method(cNoLinesOfText.klass, "initialize", VALUEFUNC(_wrap_new_NoLinesOfText), -1);
  cNoLinesOfText.mark = 0;
  cNoLinesOfText.destroy = (void (*)(void *)) free_FIX_NoLinesOfText;
  cNoLinesOfText.trackObjects = 0;
  
  cPosReqID.klass = rb_define_class_under(mQuickfix, "PosReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqID, (void *) &cPosReqID);
  rb_define_alloc_func(cPosReqID.klass, _wrap_PosReqID_allocate);
  rb_define_method(cPosReqID.klass, "initialize", VALUEFUNC(_wrap_new_PosReqID), -1);
  cPosReqID.mark = 0;
  cPosReqID.destroy = (void (*)(void *)) free_FIX_PosReqID;
  cPosReqID.trackObjects = 0;
  
  cLegSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "LegSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSecurityAltIDSource, (void *) &cLegSecurityAltIDSource);
  rb_define_alloc_func(cLegSecurityAltIDSource.klass, _wrap_LegSecurityAltIDSource_allocate);
  rb_define_method(cLegSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_LegSecurityAltIDSource), -1);
  cLegSecurityAltIDSource.mark = 0;
  cLegSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_LegSecurityAltIDSource;
  cLegSecurityAltIDSource.trackObjects = 0;
  
  cEncodedSubject.klass = rb_define_class_under(mQuickfix, "EncodedSubject", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSubject, (void *) &cEncodedSubject);
  rb_define_alloc_func(cEncodedSubject.klass, _wrap_EncodedSubject_allocate);
  rb_define_method(cEncodedSubject.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSubject), -1);
  cEncodedSubject.mark = 0;
  cEncodedSubject.destroy = (void (*)(void *)) free_FIX_EncodedSubject;
  cEncodedSubject.trackObjects = 0;
  
  cContraBroker.klass = rb_define_class_under(mQuickfix, "ContraBroker", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraBroker, (void *) &cContraBroker);
  rb_define_alloc_func(cContraBroker.klass, _wrap_ContraBroker_allocate);
  rb_define_method(cContraBroker.klass, "initialize", VALUEFUNC(_wrap_new_ContraBroker), -1);
  cContraBroker.mark = 0;
  cContraBroker.destroy = (void (*)(void *)) free_FIX_ContraBroker;
  cContraBroker.trackObjects = 0;
  
  cTradeCondition.klass = rb_define_class_under(mQuickfix, "TradeCondition", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeCondition, (void *) &cTradeCondition);
  rb_define_alloc_func(cTradeCondition.klass, _wrap_TradeCondition_allocate);
  rb_define_method(cTradeCondition.klass, "initialize", VALUEFUNC(_wrap_new_TradeCondition), -1);
  cTradeCondition.mark = 0;
  cTradeCondition.destroy = (void (*)(void *)) free_FIX_TradeCondition;
  cTradeCondition.trackObjects = 0;
  
  cPartyID.klass = rb_define_class_under(mQuickfix, "PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyID, (void *) &cPartyID);
  rb_define_alloc_func(cPartyID.klass, _wrap_PartyID_allocate);
  rb_define_method(cPartyID.klass, "initialize", VALUEFUNC(_wrap_new_PartyID), -1);
  cPartyID.mark = 0;
  cPartyID.destroy = (void (*)(void *)) free_FIX_PartyID;
  cPartyID.trackObjects = 0;
  
  cMDEntryID.klass = rb_define_class_under(mQuickfix, "MDEntryID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryID, (void *) &cMDEntryID);
  rb_define_alloc_func(cMDEntryID.klass, _wrap_MDEntryID_allocate);
  rb_define_method(cMDEntryID.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryID), -1);
  cMDEntryID.mark = 0;
  cMDEntryID.destroy = (void (*)(void *)) free_FIX_MDEntryID;
  cMDEntryID.trackObjects = 0;
  
  cUnderlyingLegSecurityExchange.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange, (void *) &cUnderlyingLegSecurityExchange);
  rb_define_alloc_func(cUnderlyingLegSecurityExchange.klass, _wrap_UnderlyingLegSecurityExchange_allocate);
  rb_define_method(cUnderlyingLegSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityExchange), -1);
  cUnderlyingLegSecurityExchange.mark = 0;
  cUnderlyingLegSecurityExchange.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityExchange;
  cUnderlyingLegSecurityExchange.trackObjects = 0;
  
  cPriceLimitType.klass = rb_define_class_under(mQuickfix, "PriceLimitType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceLimitType, (void *) &cPriceLimitType);
  rb_define_alloc_func(cPriceLimitType.klass, _wrap_PriceLimitType_allocate);
  rb_define_method(cPriceLimitType.klass, "initialize", VALUEFUNC(_wrap_new_PriceLimitType), -1);
  cPriceLimitType.mark = 0;
  cPriceLimitType.destroy = (void (*)(void *)) free_FIX_PriceLimitType;
  cPriceLimitType.trackObjects = 0;
  
  cTriggerSecurityIDSource.klass = rb_define_class_under(mQuickfix, "TriggerSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSecurityIDSource, (void *) &cTriggerSecurityIDSource);
  rb_define_alloc_func(cTriggerSecurityIDSource.klass, _wrap_TriggerSecurityIDSource_allocate);
  rb_define_method(cTriggerSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSecurityIDSource), -1);
  cTriggerSecurityIDSource.mark = 0;
  cTriggerSecurityIDSource.destroy = (void (*)(void *)) free_FIX_TriggerSecurityIDSource;
  cTriggerSecurityIDSource.trackObjects = 0;
  
  cNoUndlyInstrumentPartySubIDs.klass = rb_define_class_under(mQuickfix, "NoUndlyInstrumentPartySubIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs, (void *) &cNoUndlyInstrumentPartySubIDs);
  rb_define_alloc_func(cNoUndlyInstrumentPartySubIDs.klass, _wrap_NoUndlyInstrumentPartySubIDs_allocate);
  rb_define_method(cNoUndlyInstrumentPartySubIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoUndlyInstrumentPartySubIDs), -1);
  cNoUndlyInstrumentPartySubIDs.mark = 0;
  cNoUndlyInstrumentPartySubIDs.destroy = (void (*)(void *)) free_FIX_NoUndlyInstrumentPartySubIDs;
  cNoUndlyInstrumentPartySubIDs.trackObjects = 0;
  
  cClientBidID.klass = rb_define_class_under(mQuickfix, "ClientBidID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ClientBidID, (void *) &cClientBidID);
  rb_define_alloc_func(cClientBidID.klass, _wrap_ClientBidID_allocate);
  rb_define_method(cClientBidID.klass, "initialize", VALUEFUNC(_wrap_new_ClientBidID), -1);
  cClientBidID.mark = 0;
  cClientBidID.destroy = (void (*)(void *)) free_FIX_ClientBidID;
  cClientBidID.trackObjects = 0;
  
  cNetChgPrevDay.klass = rb_define_class_under(mQuickfix, "NetChgPrevDay", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetChgPrevDay, (void *) &cNetChgPrevDay);
  rb_define_alloc_func(cNetChgPrevDay.klass, _wrap_NetChgPrevDay_allocate);
  rb_define_method(cNetChgPrevDay.klass, "initialize", VALUEFUNC(_wrap_new_NetChgPrevDay), -1);
  cNetChgPrevDay.mark = 0;
  cNetChgPrevDay.destroy = (void (*)(void *)) free_FIX_NetChgPrevDay;
  cNetChgPrevDay.trackObjects = 0;
  
  cDefaultApplVerID.klass = rb_define_class_under(mQuickfix, "DefaultApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultApplVerID, (void *) &cDefaultApplVerID);
  rb_define_alloc_func(cDefaultApplVerID.klass, _wrap_DefaultApplVerID_allocate);
  rb_define_method(cDefaultApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_DefaultApplVerID), -1);
  cDefaultApplVerID.mark = 0;
  cDefaultApplVerID.destroy = (void (*)(void *)) free_FIX_DefaultApplVerID;
  cDefaultApplVerID.trackObjects = 0;
  
  cIOIID.klass = rb_define_class_under(mQuickfix, "IOIID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIID, (void *) &cIOIID);
  rb_define_alloc_func(cIOIID.klass, _wrap_IOIID_allocate);
  rb_define_method(cIOIID.klass, "initialize", VALUEFUNC(_wrap_new_IOIID), -1);
  cIOIID.mark = 0;
  cIOIID.destroy = (void (*)(void *)) free_FIX_IOIID;
  cIOIID.trackObjects = 0;
  
  cSpreadToBenchmark.klass = rb_define_class_under(mQuickfix, "SpreadToBenchmark", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SpreadToBenchmark, (void *) &cSpreadToBenchmark);
  rb_define_alloc_func(cSpreadToBenchmark.klass, _wrap_SpreadToBenchmark_allocate);
  rb_define_method(cSpreadToBenchmark.klass, "initialize", VALUEFUNC(_wrap_new_SpreadToBenchmark), -1);
  cSpreadToBenchmark.mark = 0;
  cSpreadToBenchmark.destroy = (void (*)(void *)) free_FIX_SpreadToBenchmark;
  cSpreadToBenchmark.trackObjects = 0;
  
  cCommType.klass = rb_define_class_under(mQuickfix, "CommType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CommType, (void *) &cCommType);
  rb_define_alloc_func(cCommType.klass, _wrap_CommType_allocate);
  rb_define_method(cCommType.klass, "initialize", VALUEFUNC(_wrap_new_CommType), -1);
  cCommType.mark = 0;
  cCommType.destroy = (void (*)(void *)) free_FIX_CommType;
  cCommType.trackObjects = 0;
  
  cRegistRejReasonCode.klass = rb_define_class_under(mQuickfix, "RegistRejReasonCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistRejReasonCode, (void *) &cRegistRejReasonCode);
  rb_define_alloc_func(cRegistRejReasonCode.klass, _wrap_RegistRejReasonCode_allocate);
  rb_define_method(cRegistRejReasonCode.klass, "initialize", VALUEFUNC(_wrap_new_RegistRejReasonCode), -1);
  cRegistRejReasonCode.mark = 0;
  cRegistRejReasonCode.destroy = (void (*)(void *)) free_FIX_RegistRejReasonCode;
  cRegistRejReasonCode.trackObjects = 0;
  
  cRelationshipRiskEncodedSecurityDesc.klass = rb_define_class_under(mQuickfix, "RelationshipRiskEncodedSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskEncodedSecurityDesc, (void *) &cRelationshipRiskEncodedSecurityDesc);
  rb_define_alloc_func(cRelationshipRiskEncodedSecurityDesc.klass, _wrap_RelationshipRiskEncodedSecurityDesc_allocate);
  rb_define_method(cRelationshipRiskEncodedSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskEncodedSecurityDesc), -1);
  cRelationshipRiskEncodedSecurityDesc.mark = 0;
  cRelationshipRiskEncodedSecurityDesc.destroy = (void (*)(void *)) free_FIX_RelationshipRiskEncodedSecurityDesc;
  cRelationshipRiskEncodedSecurityDesc.trackObjects = 0;
  
  cRelationshipRiskRestructuringType.klass = rb_define_class_under(mQuickfix, "RelationshipRiskRestructuringType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskRestructuringType, (void *) &cRelationshipRiskRestructuringType);
  rb_define_alloc_func(cRelationshipRiskRestructuringType.klass, _wrap_RelationshipRiskRestructuringType_allocate);
  rb_define_method(cRelationshipRiskRestructuringType.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskRestructuringType), -1);
  cRelationshipRiskRestructuringType.mark = 0;
  cRelationshipRiskRestructuringType.destroy = (void (*)(void *)) free_FIX_RelationshipRiskRestructuringType;
  cRelationshipRiskRestructuringType.trackObjects = 0;
  
  cSideTimeInForce.klass = rb_define_class_under(mQuickfix, "SideTimeInForce", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTimeInForce, (void *) &cSideTimeInForce);
  rb_define_alloc_func(cSideTimeInForce.klass, _wrap_SideTimeInForce_allocate);
  rb_define_method(cSideTimeInForce.klass, "initialize", VALUEFUNC(_wrap_new_SideTimeInForce), -1);
  cSideTimeInForce.mark = 0;
  cSideTimeInForce.destroy = (void (*)(void *)) free_FIX_SideTimeInForce;
  cSideTimeInForce.trackObjects = 0;
  
  cTrdRegTimestamp.klass = rb_define_class_under(mQuickfix, "TrdRegTimestamp", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRegTimestamp, (void *) &cTrdRegTimestamp);
  rb_define_alloc_func(cTrdRegTimestamp.klass, _wrap_TrdRegTimestamp_allocate);
  rb_define_method(cTrdRegTimestamp.klass, "initialize", VALUEFUNC(_wrap_new_TrdRegTimestamp), -1);
  cTrdRegTimestamp.mark = 0;
  cTrdRegTimestamp.destroy = (void (*)(void *)) free_FIX_TrdRegTimestamp;
  cTrdRegTimestamp.trackObjects = 0;
  
  cFinancialStatus.klass = rb_define_class_under(mQuickfix, "FinancialStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FinancialStatus, (void *) &cFinancialStatus);
  rb_define_alloc_func(cFinancialStatus.klass, _wrap_FinancialStatus_allocate);
  rb_define_method(cFinancialStatus.klass, "initialize", VALUEFUNC(_wrap_new_FinancialStatus), -1);
  cFinancialStatus.mark = 0;
  cFinancialStatus.destroy = (void (*)(void *)) free_FIX_FinancialStatus;
  cFinancialStatus.trackObjects = 0;
  
  cNoTrades.klass = rb_define_class_under(mQuickfix, "NoTrades", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTrades, (void *) &cNoTrades);
  rb_define_alloc_func(cNoTrades.klass, _wrap_NoTrades_allocate);
  rb_define_method(cNoTrades.klass, "initialize", VALUEFUNC(_wrap_new_NoTrades), -1);
  cNoTrades.mark = 0;
  cNoTrades.destroy = (void (*)(void *)) free_FIX_NoTrades;
  cNoTrades.trackObjects = 0;
  
  cLastFragment.klass = rb_define_class_under(mQuickfix, "LastFragment", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastFragment, (void *) &cLastFragment);
  rb_define_alloc_func(cLastFragment.klass, _wrap_LastFragment_allocate);
  rb_define_method(cLastFragment.klass, "initialize", VALUEFUNC(_wrap_new_LastFragment), -1);
  cLastFragment.mark = 0;
  cLastFragment.destroy = (void (*)(void *)) free_FIX_LastFragment;
  cLastFragment.trackObjects = 0;
  
  cPartySubID.klass = rb_define_class_under(mQuickfix, "PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartySubID, (void *) &cPartySubID);
  rb_define_alloc_func(cPartySubID.klass, _wrap_PartySubID_allocate);
  rb_define_method(cPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_PartySubID), -1);
  cPartySubID.mark = 0;
  cPartySubID.destroy = (void (*)(void *)) free_FIX_PartySubID;
  cPartySubID.trackObjects = 0;
  
  cAllocQty.klass = rb_define_class_under(mQuickfix, "AllocQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocQty, (void *) &cAllocQty);
  rb_define_alloc_func(cAllocQty.klass, _wrap_AllocQty_allocate);
  rb_define_method(cAllocQty.klass, "initialize", VALUEFUNC(_wrap_new_AllocQty), -1);
  cAllocQty.mark = 0;
  cAllocQty.destroy = (void (*)(void *)) free_FIX_AllocQty;
  cAllocQty.trackObjects = 0;
  
  cNotifyBrokerOfCredit.klass = rb_define_class_under(mQuickfix, "NotifyBrokerOfCredit", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotifyBrokerOfCredit, (void *) &cNotifyBrokerOfCredit);
  rb_define_alloc_func(cNotifyBrokerOfCredit.klass, _wrap_NotifyBrokerOfCredit_allocate);
  rb_define_method(cNotifyBrokerOfCredit.klass, "initialize", VALUEFUNC(_wrap_new_NotifyBrokerOfCredit), -1);
  cNotifyBrokerOfCredit.mark = 0;
  cNotifyBrokerOfCredit.destroy = (void (*)(void *)) free_FIX_NotifyBrokerOfCredit;
  cNotifyBrokerOfCredit.trackObjects = 0;
  
  cSideTrdRegTimestampType.klass = rb_define_class_under(mQuickfix, "SideTrdRegTimestampType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideTrdRegTimestampType, (void *) &cSideTrdRegTimestampType);
  rb_define_alloc_func(cSideTrdRegTimestampType.klass, _wrap_SideTrdRegTimestampType_allocate);
  rb_define_method(cSideTrdRegTimestampType.klass, "initialize", VALUEFUNC(_wrap_new_SideTrdRegTimestampType), -1);
  cSideTrdRegTimestampType.mark = 0;
  cSideTrdRegTimestampType.destroy = (void (*)(void *)) free_FIX_SideTrdRegTimestampType;
  cSideTrdRegTimestampType.trackObjects = 0;
  
  cAgreementDate.klass = rb_define_class_under(mQuickfix, "AgreementDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementDate, (void *) &cAgreementDate);
  rb_define_alloc_func(cAgreementDate.klass, _wrap_AgreementDate_allocate);
  rb_define_method(cAgreementDate.klass, "initialize", VALUEFUNC(_wrap_new_AgreementDate), -1);
  cAgreementDate.mark = 0;
  cAgreementDate.destroy = (void (*)(void *)) free_FIX_AgreementDate;
  cAgreementDate.trackObjects = 0;
  
  cPartySubIDType.klass = rb_define_class_under(mQuickfix, "PartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartySubIDType, (void *) &cPartySubIDType);
  rb_define_alloc_func(cPartySubIDType.klass, _wrap_PartySubIDType_allocate);
  rb_define_method(cPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_PartySubIDType), -1);
  cPartySubIDType.mark = 0;
  cPartySubIDType.destroy = (void (*)(void *)) free_FIX_PartySubIDType;
  cPartySubIDType.trackObjects = 0;
  
  cTotalNetValue.klass = rb_define_class_under(mQuickfix, "TotalNetValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotalNetValue, (void *) &cTotalNetValue);
  rb_define_alloc_func(cTotalNetValue.klass, _wrap_TotalNetValue_allocate);
  rb_define_method(cTotalNetValue.klass, "initialize", VALUEFUNC(_wrap_new_TotalNetValue), -1);
  cTotalNetValue.mark = 0;
  cTotalNetValue.destroy = (void (*)(void *)) free_FIX_TotalNetValue;
  cTotalNetValue.trackObjects = 0;
  
  cAllocNoOrdersType.klass = rb_define_class_under(mQuickfix, "AllocNoOrdersType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocNoOrdersType, (void *) &cAllocNoOrdersType);
  rb_define_alloc_func(cAllocNoOrdersType.klass, _wrap_AllocNoOrdersType_allocate);
  rb_define_method(cAllocNoOrdersType.klass, "initialize", VALUEFUNC(_wrap_new_AllocNoOrdersType), -1);
  cAllocNoOrdersType.mark = 0;
  cAllocNoOrdersType.destroy = (void (*)(void *)) free_FIX_AllocNoOrdersType;
  cAllocNoOrdersType.trackObjects = 0;
  
  cAllocLinkID.klass = rb_define_class_under(mQuickfix, "AllocLinkID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocLinkID, (void *) &cAllocLinkID);
  rb_define_alloc_func(cAllocLinkID.klass, _wrap_AllocLinkID_allocate);
  rb_define_method(cAllocLinkID.klass, "initialize", VALUEFUNC(_wrap_new_AllocLinkID), -1);
  cAllocLinkID.mark = 0;
  cAllocLinkID.destroy = (void (*)(void *)) free_FIX_AllocLinkID;
  cAllocLinkID.trackObjects = 0;
  
  cRoundingModulus.klass = rb_define_class_under(mQuickfix, "RoundingModulus", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RoundingModulus, (void *) &cRoundingModulus);
  rb_define_alloc_func(cRoundingModulus.klass, _wrap_RoundingModulus_allocate);
  rb_define_method(cRoundingModulus.klass, "initialize", VALUEFUNC(_wrap_new_RoundingModulus), -1);
  cRoundingModulus.mark = 0;
  cRoundingModulus.destroy = (void (*)(void *)) free_FIX_RoundingModulus;
  cRoundingModulus.trackObjects = 0;
  
  cOnBehalfOfCompID.klass = rb_define_class_under(mQuickfix, "OnBehalfOfCompID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfCompID, (void *) &cOnBehalfOfCompID);
  rb_define_alloc_func(cOnBehalfOfCompID.klass, _wrap_OnBehalfOfCompID_allocate);
  rb_define_method(cOnBehalfOfCompID.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfCompID), -1);
  cOnBehalfOfCompID.mark = 0;
  cOnBehalfOfCompID.destroy = (void (*)(void *)) free_FIX_OnBehalfOfCompID;
  cOnBehalfOfCompID.trackObjects = 0;
  
  cUnderlyingSecurityID.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityID, (void *) &cUnderlyingSecurityID);
  rb_define_alloc_func(cUnderlyingSecurityID.klass, _wrap_UnderlyingSecurityID_allocate);
  rb_define_method(cUnderlyingSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityID), -1);
  cUnderlyingSecurityID.mark = 0;
  cUnderlyingSecurityID.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityID;
  cUnderlyingSecurityID.trackObjects = 0;
  
  cSettlObligMsgID.klass = rb_define_class_under(mQuickfix, "SettlObligMsgID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligMsgID, (void *) &cSettlObligMsgID);
  rb_define_alloc_func(cSettlObligMsgID.klass, _wrap_SettlObligMsgID_allocate);
  rb_define_method(cSettlObligMsgID.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligMsgID), -1);
  cSettlObligMsgID.mark = 0;
  cSettlObligMsgID.destroy = (void (*)(void *)) free_FIX_SettlObligMsgID;
  cSettlObligMsgID.trackObjects = 0;
  
  cPositionLimit.klass = rb_define_class_under(mQuickfix, "PositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PositionLimit, (void *) &cPositionLimit);
  rb_define_alloc_func(cPositionLimit.klass, _wrap_PositionLimit_allocate);
  rb_define_method(cPositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_PositionLimit), -1);
  cPositionLimit.mark = 0;
  cPositionLimit.destroy = (void (*)(void *)) free_FIX_PositionLimit;
  cPositionLimit.trackObjects = 0;
  
  cSharedCommission.klass = rb_define_class_under(mQuickfix, "SharedCommission", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SharedCommission, (void *) &cSharedCommission);
  rb_define_alloc_func(cSharedCommission.klass, _wrap_SharedCommission_allocate);
  rb_define_method(cSharedCommission.klass, "initialize", VALUEFUNC(_wrap_new_SharedCommission), -1);
  cSharedCommission.mark = 0;
  cSharedCommission.destroy = (void (*)(void *)) free_FIX_SharedCommission;
  cSharedCommission.trackObjects = 0;
  
  cAllowableOneSidednessPct.klass = rb_define_class_under(mQuickfix, "AllowableOneSidednessPct", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllowableOneSidednessPct, (void *) &cAllowableOneSidednessPct);
  rb_define_alloc_func(cAllowableOneSidednessPct.klass, _wrap_AllowableOneSidednessPct_allocate);
  rb_define_method(cAllowableOneSidednessPct.klass, "initialize", VALUEFUNC(_wrap_new_AllowableOneSidednessPct), -1);
  cAllowableOneSidednessPct.mark = 0;
  cAllowableOneSidednessPct.destroy = (void (*)(void *)) free_FIX_AllowableOneSidednessPct;
  cAllowableOneSidednessPct.trackObjects = 0;
  
  cAllocText.klass = rb_define_class_under(mQuickfix, "AllocText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocText, (void *) &cAllocText);
  rb_define_alloc_func(cAllocText.klass, _wrap_AllocText_allocate);
  rb_define_method(cAllocText.klass, "initialize", VALUEFUNC(_wrap_new_AllocText), -1);
  cAllocText.mark = 0;
  cAllocText.destroy = (void (*)(void *)) free_FIX_AllocText;
  cAllocText.trackObjects = 0;
  
  cEndSeqNo.klass = rb_define_class_under(mQuickfix, "EndSeqNo", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndSeqNo, (void *) &cEndSeqNo);
  rb_define_alloc_func(cEndSeqNo.klass, _wrap_EndSeqNo_allocate);
  rb_define_method(cEndSeqNo.klass, "initialize", VALUEFUNC(_wrap_new_EndSeqNo), -1);
  cEndSeqNo.mark = 0;
  cEndSeqNo.destroy = (void (*)(void *)) free_FIX_EndSeqNo;
  cEndSeqNo.trackObjects = 0;
  
  cNoPartyIDs.klass = rb_define_class_under(mQuickfix, "NoPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartyIDs, (void *) &cNoPartyIDs);
  rb_define_alloc_func(cNoPartyIDs.klass, _wrap_NoPartyIDs_allocate);
  rb_define_method(cNoPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoPartyIDs), -1);
  cNoPartyIDs.mark = 0;
  cNoPartyIDs.destroy = (void (*)(void *)) free_FIX_NoPartyIDs;
  cNoPartyIDs.trackObjects = 0;
  
  cNoContraBrokers.klass = rb_define_class_under(mQuickfix, "NoContraBrokers", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoContraBrokers, (void *) &cNoContraBrokers);
  rb_define_alloc_func(cNoContraBrokers.klass, _wrap_NoContraBrokers_allocate);
  rb_define_method(cNoContraBrokers.klass, "initialize", VALUEFUNC(_wrap_new_NoContraBrokers), -1);
  cNoContraBrokers.mark = 0;
  cNoContraBrokers.destroy = (void (*)(void *)) free_FIX_NoContraBrokers;
  cNoContraBrokers.trackObjects = 0;
  
  cAllocLinkType.klass = rb_define_class_under(mQuickfix, "AllocLinkType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocLinkType, (void *) &cAllocLinkType);
  rb_define_alloc_func(cAllocLinkType.klass, _wrap_AllocLinkType_allocate);
  rb_define_method(cAllocLinkType.klass, "initialize", VALUEFUNC(_wrap_new_AllocLinkType), -1);
  cAllocLinkType.mark = 0;
  cAllocLinkType.destroy = (void (*)(void *)) free_FIX_AllocLinkType;
  cAllocLinkType.trackObjects = 0;
  
  cUnderlyingAllocationPercent.klass = rb_define_class_under(mQuickfix, "UnderlyingAllocationPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingAllocationPercent, (void *) &cUnderlyingAllocationPercent);
  rb_define_alloc_func(cUnderlyingAllocationPercent.klass, _wrap_UnderlyingAllocationPercent_allocate);
  rb_define_method(cUnderlyingAllocationPercent.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingAllocationPercent), -1);
  cUnderlyingAllocationPercent.mark = 0;
  cUnderlyingAllocationPercent.destroy = (void (*)(void *)) free_FIX_UnderlyingAllocationPercent;
  cUnderlyingAllocationPercent.trackObjects = 0;
  
  cAllocAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "AllocAccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAccruedInterestAmt, (void *) &cAllocAccruedInterestAmt);
  rb_define_alloc_func(cAllocAccruedInterestAmt.klass, _wrap_AllocAccruedInterestAmt_allocate);
  rb_define_method(cAllocAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_AllocAccruedInterestAmt), -1);
  cAllocAccruedInterestAmt.mark = 0;
  cAllocAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_AllocAccruedInterestAmt;
  cAllocAccruedInterestAmt.trackObjects = 0;
  
  cRiskSecuritySubType.klass = rb_define_class_under(mQuickfix, "RiskSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecuritySubType, (void *) &cRiskSecuritySubType);
  rb_define_alloc_func(cRiskSecuritySubType.klass, _wrap_RiskSecuritySubType_allocate);
  rb_define_method(cRiskSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecuritySubType), -1);
  cRiskSecuritySubType.mark = 0;
  cRiskSecuritySubType.destroy = (void (*)(void *)) free_FIX_RiskSecuritySubType;
  cRiskSecuritySubType.trackObjects = 0;
  
  cEncodedSecurityListDesc.klass = rb_define_class_under(mQuickfix, "EncodedSecurityListDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityListDesc, (void *) &cEncodedSecurityListDesc);
  rb_define_alloc_func(cEncodedSecurityListDesc.klass, _wrap_EncodedSecurityListDesc_allocate);
  rb_define_method(cEncodedSecurityListDesc.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityListDesc), -1);
  cEncodedSecurityListDesc.mark = 0;
  cEncodedSecurityListDesc.destroy = (void (*)(void *)) free_FIX_EncodedSecurityListDesc;
  cEncodedSecurityListDesc.trackObjects = 0;
  
  cEncryptedPasswordLen.klass = rb_define_class_under(mQuickfix, "EncryptedPasswordLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedPasswordLen, (void *) &cEncryptedPasswordLen);
  rb_define_alloc_func(cEncryptedPasswordLen.klass, _wrap_EncryptedPasswordLen_allocate);
  rb_define_method(cEncryptedPasswordLen.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedPasswordLen), -1);
  cEncryptedPasswordLen.mark = 0;
  cEncryptedPasswordLen.destroy = (void (*)(void *)) free_FIX_EncryptedPasswordLen;
  cEncryptedPasswordLen.trackObjects = 0;
  
  cLegDividendYield.klass = rb_define_class_under(mQuickfix, "LegDividendYield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegDividendYield, (void *) &cLegDividendYield);
  rb_define_alloc_func(cLegDividendYield.klass, _wrap_LegDividendYield_allocate);
  rb_define_method(cLegDividendYield.klass, "initialize", VALUEFUNC(_wrap_new_LegDividendYield), -1);
  cLegDividendYield.mark = 0;
  cLegDividendYield.destroy = (void (*)(void *)) free_FIX_LegDividendYield;
  cLegDividendYield.trackObjects = 0;
  
  cRefreshIndicator.klass = rb_define_class_under(mQuickfix, "RefreshIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefreshIndicator, (void *) &cRefreshIndicator);
  rb_define_alloc_func(cRefreshIndicator.klass, _wrap_RefreshIndicator_allocate);
  rb_define_method(cRefreshIndicator.klass, "initialize", VALUEFUNC(_wrap_new_RefreshIndicator), -1);
  cRefreshIndicator.mark = 0;
  cRefreshIndicator.destroy = (void (*)(void *)) free_FIX_RefreshIndicator;
  cRefreshIndicator.trackObjects = 0;
  
  cSideSettlCurrency.klass = rb_define_class_under(mQuickfix, "SideSettlCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideSettlCurrency, (void *) &cSideSettlCurrency);
  rb_define_alloc_func(cSideSettlCurrency.klass, _wrap_SideSettlCurrency_allocate);
  rb_define_method(cSideSettlCurrency.klass, "initialize", VALUEFUNC(_wrap_new_SideSettlCurrency), -1);
  cSideSettlCurrency.mark = 0;
  cSideSettlCurrency.destroy = (void (*)(void *)) free_FIX_SideSettlCurrency;
  cSideSettlCurrency.trackObjects = 0;
  
  cUnderlyingSettlementType.klass = rb_define_class_under(mQuickfix, "UnderlyingSettlementType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSettlementType, (void *) &cUnderlyingSettlementType);
  rb_define_alloc_func(cUnderlyingSettlementType.klass, _wrap_UnderlyingSettlementType_allocate);
  rb_define_method(cUnderlyingSettlementType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSettlementType), -1);
  cUnderlyingSettlementType.mark = 0;
  cUnderlyingSettlementType.destroy = (void (*)(void *)) free_FIX_UnderlyingSettlementType;
  cUnderlyingSettlementType.trackObjects = 0;
  
  cOrderCapacityQty.klass = rb_define_class_under(mQuickfix, "OrderCapacityQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderCapacityQty, (void *) &cOrderCapacityQty);
  rb_define_alloc_func(cOrderCapacityQty.klass, _wrap_OrderCapacityQty_allocate);
  rb_define_method(cOrderCapacityQty.klass, "initialize", VALUEFUNC(_wrap_new_OrderCapacityQty), -1);
  cOrderCapacityQty.mark = 0;
  cOrderCapacityQty.destroy = (void (*)(void *)) free_FIX_OrderCapacityQty;
  cOrderCapacityQty.trackObjects = 0;
  
  cLongQty.klass = rb_define_class_under(mQuickfix, "LongQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LongQty, (void *) &cLongQty);
  rb_define_alloc_func(cLongQty.klass, _wrap_LongQty_allocate);
  rb_define_method(cLongQty.klass, "initialize", VALUEFUNC(_wrap_new_LongQty), -1);
  cLongQty.mark = 0;
  cLongQty.destroy = (void (*)(void *)) free_FIX_LongQty;
  cLongQty.trackObjects = 0;
  
  cNoPartyAltIDs.klass = rb_define_class_under(mQuickfix, "NoPartyAltIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoPartyAltIDs, (void *) &cNoPartyAltIDs);
  rb_define_alloc_func(cNoPartyAltIDs.klass, _wrap_NoPartyAltIDs_allocate);
  rb_define_method(cNoPartyAltIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoPartyAltIDs), -1);
  cNoPartyAltIDs.mark = 0;
  cNoPartyAltIDs.destroy = (void (*)(void *)) free_FIX_NoPartyAltIDs;
  cNoPartyAltIDs.trackObjects = 0;
  
  cDerivativeSettlMethod.klass = rb_define_class_under(mQuickfix, "DerivativeSettlMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSettlMethod, (void *) &cDerivativeSettlMethod);
  rb_define_alloc_func(cDerivativeSettlMethod.klass, _wrap_DerivativeSettlMethod_allocate);
  rb_define_method(cDerivativeSettlMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSettlMethod), -1);
  cDerivativeSettlMethod.mark = 0;
  cDerivativeSettlMethod.destroy = (void (*)(void *)) free_FIX_DerivativeSettlMethod;
  cDerivativeSettlMethod.trackObjects = 0;
  
  cTriggerTradingSessionID.klass = rb_define_class_under(mQuickfix, "TriggerTradingSessionID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerTradingSessionID, (void *) &cTriggerTradingSessionID);
  rb_define_alloc_func(cTriggerTradingSessionID.klass, _wrap_TriggerTradingSessionID_allocate);
  rb_define_method(cTriggerTradingSessionID.klass, "initialize", VALUEFUNC(_wrap_new_TriggerTradingSessionID), -1);
  cTriggerTradingSessionID.mark = 0;
  cTriggerTradingSessionID.destroy = (void (*)(void *)) free_FIX_TriggerTradingSessionID;
  cTriggerTradingSessionID.trackObjects = 0;
  
  cDisplayMethod.klass = rb_define_class_under(mQuickfix, "DisplayMethod", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DisplayMethod, (void *) &cDisplayMethod);
  rb_define_alloc_func(cDisplayMethod.klass, _wrap_DisplayMethod_allocate);
  rb_define_method(cDisplayMethod.klass, "initialize", VALUEFUNC(_wrap_new_DisplayMethod), -1);
  cDisplayMethod.mark = 0;
  cDisplayMethod.destroy = (void (*)(void *)) free_FIX_DisplayMethod;
  cDisplayMethod.trackObjects = 0;
  
  cRptSeq.klass = rb_define_class_under(mQuickfix, "RptSeq", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RptSeq, (void *) &cRptSeq);
  rb_define_alloc_func(cRptSeq.klass, _wrap_RptSeq_allocate);
  rb_define_method(cRptSeq.klass, "initialize", VALUEFUNC(_wrap_new_RptSeq), -1);
  cRptSeq.mark = 0;
  cRptSeq.destroy = (void (*)(void *)) free_FIX_RptSeq;
  cRptSeq.trackObjects = 0;
  
  cMDEntryOriginator.klass = rb_define_class_under(mQuickfix, "MDEntryOriginator", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDEntryOriginator, (void *) &cMDEntryOriginator);
  rb_define_alloc_func(cMDEntryOriginator.klass, _wrap_MDEntryOriginator_allocate);
  rb_define_method(cMDEntryOriginator.klass, "initialize", VALUEFUNC(_wrap_new_MDEntryOriginator), -1);
  cMDEntryOriginator.mark = 0;
  cMDEntryOriginator.destroy = (void (*)(void *)) free_FIX_MDEntryOriginator;
  cMDEntryOriginator.trackObjects = 0;
  
  cLegInstrRegistry.klass = rb_define_class_under(mQuickfix, "LegInstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegInstrRegistry, (void *) &cLegInstrRegistry);
  rb_define_alloc_func(cLegInstrRegistry.klass, _wrap_LegInstrRegistry_allocate);
  rb_define_method(cLegInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_LegInstrRegistry), -1);
  cLegInstrRegistry.mark = 0;
  cLegInstrRegistry.destroy = (void (*)(void *)) free_FIX_LegInstrRegistry;
  cLegInstrRegistry.trackObjects = 0;
  
  cFillQty.klass = rb_define_class_under(mQuickfix, "FillQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FillQty, (void *) &cFillQty);
  rb_define_alloc_func(cFillQty.klass, _wrap_FillQty_allocate);
  rb_define_method(cFillQty.klass, "initialize", VALUEFUNC(_wrap_new_FillQty), -1);
  cFillQty.mark = 0;
  cFillQty.destroy = (void (*)(void *)) free_FIX_FillQty;
  cFillQty.trackObjects = 0;
  
  cPegSecurityIDSource.klass = rb_define_class_under(mQuickfix, "PegSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PegSecurityIDSource, (void *) &cPegSecurityIDSource);
  rb_define_alloc_func(cPegSecurityIDSource.klass, _wrap_PegSecurityIDSource_allocate);
  rb_define_method(cPegSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_PegSecurityIDSource), -1);
  cPegSecurityIDSource.mark = 0;
  cPegSecurityIDSource.destroy = (void (*)(void *)) free_FIX_PegSecurityIDSource;
  cPegSecurityIDSource.trackObjects = 0;
  
  cMaturityTime.klass = rb_define_class_under(mQuickfix, "MaturityTime", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityTime, (void *) &cMaturityTime);
  rb_define_alloc_func(cMaturityTime.klass, _wrap_MaturityTime_allocate);
  rb_define_method(cMaturityTime.klass, "initialize", VALUEFUNC(_wrap_new_MaturityTime), -1);
  cMaturityTime.mark = 0;
  cMaturityTime.destroy = (void (*)(void *)) free_FIX_MaturityTime;
  cMaturityTime.trackObjects = 0;
  
  cMDFeedType.klass = rb_define_class_under(mQuickfix, "MDFeedType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDFeedType, (void *) &cMDFeedType);
  rb_define_alloc_func(cMDFeedType.klass, _wrap_MDFeedType_allocate);
  rb_define_method(cMDFeedType.klass, "initialize", VALUEFUNC(_wrap_new_MDFeedType), -1);
  cMDFeedType.mark = 0;
  cMDFeedType.destroy = (void (*)(void *)) free_FIX_MDFeedType;
  cMDFeedType.trackObjects = 0;
  
  cCollStatus.klass = rb_define_class_under(mQuickfix, "CollStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollStatus, (void *) &cCollStatus);
  rb_define_alloc_func(cCollStatus.klass, _wrap_CollStatus_allocate);
  rb_define_method(cCollStatus.klass, "initialize", VALUEFUNC(_wrap_new_CollStatus), -1);
  cCollStatus.mark = 0;
  cCollStatus.destroy = (void (*)(void *)) free_FIX_CollStatus;
  cCollStatus.trackObjects = 0;
  
  cUnderlyingSecuritySubType.klass = rb_define_class_under(mQuickfix, "UnderlyingSecuritySubType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecuritySubType, (void *) &cUnderlyingSecuritySubType);
  rb_define_alloc_func(cUnderlyingSecuritySubType.klass, _wrap_UnderlyingSecuritySubType_allocate);
  rb_define_method(cUnderlyingSecuritySubType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecuritySubType), -1);
  cUnderlyingSecuritySubType.mark = 0;
  cUnderlyingSecuritySubType.destroy = (void (*)(void *)) free_FIX_UnderlyingSecuritySubType;
  cUnderlyingSecuritySubType.trackObjects = 0;
  
  cCstmApplVerID.klass = rb_define_class_under(mQuickfix, "CstmApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CstmApplVerID, (void *) &cCstmApplVerID);
  rb_define_alloc_func(cCstmApplVerID.klass, _wrap_CstmApplVerID_allocate);
  rb_define_method(cCstmApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_CstmApplVerID), -1);
  cCstmApplVerID.mark = 0;
  cCstmApplVerID.destroy = (void (*)(void *)) free_FIX_CstmApplVerID;
  cCstmApplVerID.trackObjects = 0;
  
  cDefaultApplExtID.klass = rb_define_class_under(mQuickfix, "DefaultApplExtID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultApplExtID, (void *) &cDefaultApplExtID);
  rb_define_alloc_func(cDefaultApplExtID.klass, _wrap_DefaultApplExtID_allocate);
  rb_define_method(cDefaultApplExtID.klass, "initialize", VALUEFUNC(_wrap_new_DefaultApplExtID), -1);
  cDefaultApplExtID.mark = 0;
  cDefaultApplExtID.destroy = (void (*)(void *)) free_FIX_DefaultApplExtID;
  cDefaultApplExtID.trackObjects = 0;
  
  cNoDerivativeSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoDerivativeSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeSecurityAltID, (void *) &cNoDerivativeSecurityAltID);
  rb_define_alloc_func(cNoDerivativeSecurityAltID.klass, _wrap_NoDerivativeSecurityAltID_allocate);
  rb_define_method(cNoDerivativeSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeSecurityAltID), -1);
  cNoDerivativeSecurityAltID.mark = 0;
  cNoDerivativeSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoDerivativeSecurityAltID;
  cNoDerivativeSecurityAltID.trackObjects = 0;
  
  cSideValueInd.klass = rb_define_class_under(mQuickfix, "SideValueInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideValueInd, (void *) &cSideValueInd);
  rb_define_alloc_func(cSideValueInd.klass, _wrap_SideValueInd_allocate);
  rb_define_method(cSideValueInd.klass, "initialize", VALUEFUNC(_wrap_new_SideValueInd), -1);
  cSideValueInd.mark = 0;
  cSideValueInd.destroy = (void (*)(void *)) free_FIX_SideValueInd;
  cSideValueInd.trackObjects = 0;
  
  cEncodedText.klass = rb_define_class_under(mQuickfix, "EncodedText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedText, (void *) &cEncodedText);
  rb_define_alloc_func(cEncodedText.klass, _wrap_EncodedText_allocate);
  rb_define_method(cEncodedText.klass, "initialize", VALUEFUNC(_wrap_new_EncodedText), -1);
  cEncodedText.mark = 0;
  cEncodedText.destroy = (void (*)(void *)) free_FIX_EncodedText;
  cEncodedText.trackObjects = 0;
  
  cAccount.klass = rb_define_class_under(mQuickfix, "Account", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Account, (void *) &cAccount);
  rb_define_alloc_func(cAccount.klass, _wrap_Account_allocate);
  rb_define_method(cAccount.klass, "initialize", VALUEFUNC(_wrap_new_Account), -1);
  cAccount.mark = 0;
  cAccount.destroy = (void (*)(void *)) free_FIX_Account;
  cAccount.trackObjects = 0;
  
  cTriggerNewPrice.klass = rb_define_class_under(mQuickfix, "TriggerNewPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerNewPrice, (void *) &cTriggerNewPrice);
  rb_define_alloc_func(cTriggerNewPrice.klass, _wrap_TriggerNewPrice_allocate);
  rb_define_method(cTriggerNewPrice.klass, "initialize", VALUEFUNC(_wrap_new_TriggerNewPrice), -1);
  cTriggerNewPrice.mark = 0;
  cTriggerNewPrice.destroy = (void (*)(void *)) free_FIX_TriggerNewPrice;
  cTriggerNewPrice.trackObjects = 0;
  
  cUndlyInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartyRole, (void *) &cUndlyInstrumentPartyRole);
  rb_define_alloc_func(cUndlyInstrumentPartyRole.klass, _wrap_UndlyInstrumentPartyRole_allocate);
  rb_define_method(cUndlyInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartyRole), -1);
  cUndlyInstrumentPartyRole.mark = 0;
  cUndlyInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartyRole;
  cUndlyInstrumentPartyRole.trackObjects = 0;
  
  cMsgDirection.klass = rb_define_class_under(mQuickfix, "MsgDirection", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MsgDirection, (void *) &cMsgDirection);
  rb_define_alloc_func(cMsgDirection.klass, _wrap_MsgDirection_allocate);
  rb_define_method(cMsgDirection.klass, "initialize", VALUEFUNC(_wrap_new_MsgDirection), -1);
  cMsgDirection.mark = 0;
  cMsgDirection.destroy = (void (*)(void *)) free_FIX_MsgDirection;
  cMsgDirection.trackObjects = 0;
  
  cLegMaturityDate.klass = rb_define_class_under(mQuickfix, "LegMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegMaturityDate, (void *) &cLegMaturityDate);
  rb_define_alloc_func(cLegMaturityDate.klass, _wrap_LegMaturityDate_allocate);
  rb_define_method(cLegMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_LegMaturityDate), -1);
  cLegMaturityDate.mark = 0;
  cLegMaturityDate.destroy = (void (*)(void *)) free_FIX_LegMaturityDate;
  cLegMaturityDate.trackObjects = 0;
  
  cUnderlyingContractMultiplierUnit.klass = rb_define_class_under(mQuickfix, "UnderlyingContractMultiplierUnit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit, (void *) &cUnderlyingContractMultiplierUnit);
  rb_define_alloc_func(cUnderlyingContractMultiplierUnit.klass, _wrap_UnderlyingContractMultiplierUnit_allocate);
  rb_define_method(cUnderlyingContractMultiplierUnit.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingContractMultiplierUnit), -1);
  cUnderlyingContractMultiplierUnit.mark = 0;
  cUnderlyingContractMultiplierUnit.destroy = (void (*)(void *)) free_FIX_UnderlyingContractMultiplierUnit;
  cUnderlyingContractMultiplierUnit.trackObjects = 0;
  
  cInputSource.klass = rb_define_class_under(mQuickfix, "InputSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InputSource, (void *) &cInputSource);
  rb_define_alloc_func(cInputSource.klass, _wrap_InputSource_allocate);
  rb_define_method(cInputSource.klass, "initialize", VALUEFUNC(_wrap_new_InputSource), -1);
  cInputSource.mark = 0;
  cInputSource.destroy = (void (*)(void *)) free_FIX_InputSource;
  cInputSource.trackObjects = 0;
  
  cMDUpdateAction.klass = rb_define_class_under(mQuickfix, "MDUpdateAction", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDUpdateAction, (void *) &cMDUpdateAction);
  rb_define_alloc_func(cMDUpdateAction.klass, _wrap_MDUpdateAction_allocate);
  rb_define_method(cMDUpdateAction.klass, "initialize", VALUEFUNC(_wrap_new_MDUpdateAction), -1);
  cMDUpdateAction.mark = 0;
  cMDUpdateAction.destroy = (void (*)(void *)) free_FIX_MDUpdateAction;
  cMDUpdateAction.trackObjects = 0;
  
  cMatchStatus.klass = rb_define_class_under(mQuickfix, "MatchStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MatchStatus, (void *) &cMatchStatus);
  rb_define_alloc_func(cMatchStatus.klass, _wrap_MatchStatus_allocate);
  rb_define_method(cMatchStatus.klass, "initialize", VALUEFUNC(_wrap_new_MatchStatus), -1);
  cMatchStatus.mark = 0;
  cMatchStatus.destroy = (void (*)(void *)) free_FIX_MatchStatus;
  cMatchStatus.trackObjects = 0;
  
  cRateSource.klass = rb_define_class_under(mQuickfix, "RateSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RateSource, (void *) &cRateSource);
  rb_define_alloc_func(cRateSource.klass, _wrap_RateSource_allocate);
  rb_define_method(cRateSource.klass, "initialize", VALUEFUNC(_wrap_new_RateSource), -1);
  cRateSource.mark = 0;
  cRateSource.destroy = (void (*)(void *)) free_FIX_RateSource;
  cRateSource.trackObjects = 0;
  
  cAllocPositionEffect.klass = rb_define_class_under(mQuickfix, "AllocPositionEffect", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocPositionEffect, (void *) &cAllocPositionEffect);
  rb_define_alloc_func(cAllocPositionEffect.klass, _wrap_AllocPositionEffect_allocate);
  rb_define_method(cAllocPositionEffect.klass, "initialize", VALUEFUNC(_wrap_new_AllocPositionEffect), -1);
  cAllocPositionEffect.mark = 0;
  cAllocPositionEffect.destroy = (void (*)(void *)) free_FIX_AllocPositionEffect;
  cAllocPositionEffect.trackObjects = 0;
  
  cPartyIDSource.klass = rb_define_class_under(mQuickfix, "PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyIDSource, (void *) &cPartyIDSource);
  rb_define_alloc_func(cPartyIDSource.klass, _wrap_PartyIDSource_allocate);
  rb_define_method(cPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_PartyIDSource), -1);
  cPartyIDSource.mark = 0;
  cPartyIDSource.destroy = (void (*)(void *)) free_FIX_PartyIDSource;
  cPartyIDSource.trackObjects = 0;
  
  cEncodedUnderlyingIssuer.klass = rb_define_class_under(mQuickfix, "EncodedUnderlyingIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedUnderlyingIssuer, (void *) &cEncodedUnderlyingIssuer);
  rb_define_alloc_func(cEncodedUnderlyingIssuer.klass, _wrap_EncodedUnderlyingIssuer_allocate);
  rb_define_method(cEncodedUnderlyingIssuer.klass, "initialize", VALUEFUNC(_wrap_new_EncodedUnderlyingIssuer), -1);
  cEncodedUnderlyingIssuer.mark = 0;
  cEncodedUnderlyingIssuer.destroy = (void (*)(void *)) free_FIX_EncodedUnderlyingIssuer;
  cEncodedUnderlyingIssuer.trackObjects = 0;
  
  cNoRequestedPartyRoles.klass = rb_define_class_under(mQuickfix, "NoRequestedPartyRoles", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRequestedPartyRoles, (void *) &cNoRequestedPartyRoles);
  rb_define_alloc_func(cNoRequestedPartyRoles.klass, _wrap_NoRequestedPartyRoles_allocate);
  rb_define_method(cNoRequestedPartyRoles.klass, "initialize", VALUEFUNC(_wrap_new_NoRequestedPartyRoles), -1);
  cNoRequestedPartyRoles.mark = 0;
  cNoRequestedPartyRoles.destroy = (void (*)(void *)) free_FIX_NoRequestedPartyRoles;
  cNoRequestedPartyRoles.trackObjects = 0;
  
  cEncryptedPassword.klass = rb_define_class_under(mQuickfix, "EncryptedPassword", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedPassword, (void *) &cEncryptedPassword);
  rb_define_alloc_func(cEncryptedPassword.klass, _wrap_EncryptedPassword_allocate);
  rb_define_method(cEncryptedPassword.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedPassword), -1);
  cEncryptedPassword.mark = 0;
  cEncryptedPassword.destroy = (void (*)(void *)) free_FIX_EncryptedPassword;
  cEncryptedPassword.trackObjects = 0;
  
  cTriggerNewQty.klass = rb_define_class_under(mQuickfix, "TriggerNewQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerNewQty, (void *) &cTriggerNewQty);
  rb_define_alloc_func(cTriggerNewQty.klass, _wrap_TriggerNewQty_allocate);
  rb_define_method(cTriggerNewQty.klass, "initialize", VALUEFUNC(_wrap_new_TriggerNewQty), -1);
  cTriggerNewQty.mark = 0;
  cTriggerNewQty.destroy = (void (*)(void *)) free_FIX_TriggerNewQty;
  cTriggerNewQty.trackObjects = 0;
  
  cLegLastForwardPoints.klass = rb_define_class_under(mQuickfix, "LegLastForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLastForwardPoints, (void *) &cLegLastForwardPoints);
  rb_define_alloc_func(cLegLastForwardPoints.klass, _wrap_LegLastForwardPoints_allocate);
  rb_define_method(cLegLastForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LegLastForwardPoints), -1);
  cLegLastForwardPoints.mark = 0;
  cLegLastForwardPoints.destroy = (void (*)(void *)) free_FIX_LegLastForwardPoints;
  cLegLastForwardPoints.trackObjects = 0;
  
  cTotNumTradeReports.klass = rb_define_class_under(mQuickfix, "TotNumTradeReports", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNumTradeReports, (void *) &cTotNumTradeReports);
  rb_define_alloc_func(cTotNumTradeReports.klass, _wrap_TotNumTradeReports_allocate);
  rb_define_method(cTotNumTradeReports.klass, "initialize", VALUEFUNC(_wrap_new_TotNumTradeReports), -1);
  cTotNumTradeReports.mark = 0;
  cTotNumTradeReports.destroy = (void (*)(void *)) free_FIX_TotNumTradeReports;
  cTotNumTradeReports.trackObjects = 0;
  
  cRefApplVerID.klass = rb_define_class_under(mQuickfix, "RefApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplVerID, (void *) &cRefApplVerID);
  rb_define_alloc_func(cRefApplVerID.klass, _wrap_RefApplVerID_allocate);
  rb_define_method(cRefApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplVerID), -1);
  cRefApplVerID.mark = 0;
  cRefApplVerID.destroy = (void (*)(void *)) free_FIX_RefApplVerID;
  cRefApplVerID.trackObjects = 0;
  
  cLastSpotRate.klass = rb_define_class_under(mQuickfix, "LastSpotRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastSpotRate, (void *) &cLastSpotRate);
  rb_define_alloc_func(cLastSpotRate.klass, _wrap_LastSpotRate_allocate);
  rb_define_method(cLastSpotRate.klass, "initialize", VALUEFUNC(_wrap_new_LastSpotRate), -1);
  cLastSpotRate.mark = 0;
  cLastSpotRate.destroy = (void (*)(void *)) free_FIX_LastSpotRate;
  cLastSpotRate.trackObjects = 0;
  
  cPrice.klass = rb_define_class_under(mQuickfix, "Price", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Price, (void *) &cPrice);
  rb_define_alloc_func(cPrice.klass, _wrap_Price_allocate);
  rb_define_method(cPrice.klass, "initialize", VALUEFUNC(_wrap_new_Price), -1);
  cPrice.mark = 0;
  cPrice.destroy = (void (*)(void *)) free_FIX_Price;
  cPrice.trackObjects = 0;
  
  cUnderlyingSecurityIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityIDSource, (void *) &cUnderlyingSecurityIDSource);
  rb_define_alloc_func(cUnderlyingSecurityIDSource.klass, _wrap_UnderlyingSecurityIDSource_allocate);
  rb_define_method(cUnderlyingSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityIDSource), -1);
  cUnderlyingSecurityIDSource.mark = 0;
  cUnderlyingSecurityIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityIDSource;
  cUnderlyingSecurityIDSource.trackObjects = 0;
  
  cTotNoSecurityTypes.klass = rb_define_class_under(mQuickfix, "TotNoSecurityTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoSecurityTypes, (void *) &cTotNoSecurityTypes);
  rb_define_alloc_func(cTotNoSecurityTypes.klass, _wrap_TotNoSecurityTypes_allocate);
  rb_define_method(cTotNoSecurityTypes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoSecurityTypes), -1);
  cTotNoSecurityTypes.mark = 0;
  cTotNoSecurityTypes.destroy = (void (*)(void *)) free_FIX_TotNoSecurityTypes;
  cTotNoSecurityTypes.trackObjects = 0;
  
  cRelationshipRiskInstrumentMultiplier.klass = rb_define_class_under(mQuickfix, "RelationshipRiskInstrumentMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskInstrumentMultiplier, (void *) &cRelationshipRiskInstrumentMultiplier);
  rb_define_alloc_func(cRelationshipRiskInstrumentMultiplier.klass, _wrap_RelationshipRiskInstrumentMultiplier_allocate);
  rb_define_method(cRelationshipRiskInstrumentMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskInstrumentMultiplier), -1);
  cRelationshipRiskInstrumentMultiplier.mark = 0;
  cRelationshipRiskInstrumentMultiplier.destroy = (void (*)(void *)) free_FIX_RelationshipRiskInstrumentMultiplier;
  cRelationshipRiskInstrumentMultiplier.trackObjects = 0;
  
  cNoRiskInstruments.klass = rb_define_class_under(mQuickfix, "NoRiskInstruments", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRiskInstruments, (void *) &cNoRiskInstruments);
  rb_define_alloc_func(cNoRiskInstruments.klass, _wrap_NoRiskInstruments_allocate);
  rb_define_method(cNoRiskInstruments.klass, "initialize", VALUEFUNC(_wrap_new_NoRiskInstruments), -1);
  cNoRiskInstruments.mark = 0;
  cNoRiskInstruments.destroy = (void (*)(void *)) free_FIX_NoRiskInstruments;
  cNoRiskInstruments.trackObjects = 0;
  
  cReportedPx.klass = rb_define_class_under(mQuickfix, "ReportedPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReportedPx, (void *) &cReportedPx);
  rb_define_alloc_func(cReportedPx.klass, _wrap_ReportedPx_allocate);
  rb_define_method(cReportedPx.klass, "initialize", VALUEFUNC(_wrap_new_ReportedPx), -1);
  cReportedPx.mark = 0;
  cReportedPx.destroy = (void (*)(void *)) free_FIX_ReportedPx;
  cReportedPx.trackObjects = 0;
  
  cLegSymbol.klass = rb_define_class_under(mQuickfix, "LegSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSymbol, (void *) &cLegSymbol);
  rb_define_alloc_func(cLegSymbol.klass, _wrap_LegSymbol_allocate);
  rb_define_method(cLegSymbol.klass, "initialize", VALUEFUNC(_wrap_new_LegSymbol), -1);
  cLegSymbol.mark = 0;
  cLegSymbol.destroy = (void (*)(void *)) free_FIX_LegSymbol;
  cLegSymbol.trackObjects = 0;
  
  cLegIssuer.klass = rb_define_class_under(mQuickfix, "LegIssuer", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIssuer, (void *) &cLegIssuer);
  rb_define_alloc_func(cLegIssuer.klass, _wrap_LegIssuer_allocate);
  rb_define_method(cLegIssuer.klass, "initialize", VALUEFUNC(_wrap_new_LegIssuer), -1);
  cLegIssuer.mark = 0;
  cLegIssuer.destroy = (void (*)(void *)) free_FIX_LegIssuer;
  cLegIssuer.trackObjects = 0;
  
  cRegistDetls.klass = rb_define_class_under(mQuickfix, "RegistDetls", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RegistDetls, (void *) &cRegistDetls);
  rb_define_alloc_func(cRegistDetls.klass, _wrap_RegistDetls_allocate);
  rb_define_method(cRegistDetls.klass, "initialize", VALUEFUNC(_wrap_new_RegistDetls), -1);
  cRegistDetls.mark = 0;
  cRegistDetls.destroy = (void (*)(void *)) free_FIX_RegistDetls;
  cRegistDetls.trackObjects = 0;
  
  cUnderlyingLegSecurityID.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityID, (void *) &cUnderlyingLegSecurityID);
  rb_define_alloc_func(cUnderlyingLegSecurityID.klass, _wrap_UnderlyingLegSecurityID_allocate);
  rb_define_method(cUnderlyingLegSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityID), -1);
  cUnderlyingLegSecurityID.mark = 0;
  cUnderlyingLegSecurityID.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityID;
  cUnderlyingLegSecurityID.trackObjects = 0;
  
  cMinLotSize.klass = rb_define_class_under(mQuickfix, "MinLotSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinLotSize, (void *) &cMinLotSize);
  rb_define_alloc_func(cMinLotSize.klass, _wrap_MinLotSize_allocate);
  rb_define_method(cMinLotSize.klass, "initialize", VALUEFUNC(_wrap_new_MinLotSize), -1);
  cMinLotSize.mark = 0;
  cMinLotSize.destroy = (void (*)(void *)) free_FIX_MinLotSize;
  cMinLotSize.trackObjects = 0;
  
  cNumTickets.klass = rb_define_class_under(mQuickfix, "NumTickets", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumTickets, (void *) &cNumTickets);
  rb_define_alloc_func(cNumTickets.klass, _wrap_NumTickets_allocate);
  rb_define_method(cNumTickets.klass, "initialize", VALUEFUNC(_wrap_new_NumTickets), -1);
  cNumTickets.mark = 0;
  cNumTickets.destroy = (void (*)(void *)) free_FIX_NumTickets;
  cNumTickets.trackObjects = 0;
  
  cLegLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "LegLocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegLocaleOfIssue, (void *) &cLegLocaleOfIssue);
  rb_define_alloc_func(cLegLocaleOfIssue.klass, _wrap_LegLocaleOfIssue_allocate);
  rb_define_method(cLegLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_LegLocaleOfIssue), -1);
  cLegLocaleOfIssue.mark = 0;
  cLegLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_LegLocaleOfIssue;
  cLegLocaleOfIssue.trackObjects = 0;
  
  cExchangeForPhysical.klass = rb_define_class_under(mQuickfix, "ExchangeForPhysical", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExchangeForPhysical, (void *) &cExchangeForPhysical);
  rb_define_alloc_func(cExchangeForPhysical.klass, _wrap_ExchangeForPhysical_allocate);
  rb_define_method(cExchangeForPhysical.klass, "initialize", VALUEFUNC(_wrap_new_ExchangeForPhysical), -1);
  cExchangeForPhysical.mark = 0;
  cExchangeForPhysical.destroy = (void (*)(void *)) free_FIX_ExchangeForPhysical;
  cExchangeForPhysical.trackObjects = 0;
  
  cSecurityTradingEvent.klass = rb_define_class_under(mQuickfix, "SecurityTradingEvent", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityTradingEvent, (void *) &cSecurityTradingEvent);
  rb_define_alloc_func(cSecurityTradingEvent.klass, _wrap_SecurityTradingEvent_allocate);
  rb_define_method(cSecurityTradingEvent.klass, "initialize", VALUEFUNC(_wrap_new_SecurityTradingEvent), -1);
  cSecurityTradingEvent.mark = 0;
  cSecurityTradingEvent.destroy = (void (*)(void *)) free_FIX_SecurityTradingEvent;
  cSecurityTradingEvent.trackObjects = 0;
  
  cMinPriceIncrementAmount.klass = rb_define_class_under(mQuickfix, "MinPriceIncrementAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MinPriceIncrementAmount, (void *) &cMinPriceIncrementAmount);
  rb_define_alloc_func(cMinPriceIncrementAmount.klass, _wrap_MinPriceIncrementAmount_allocate);
  rb_define_method(cMinPriceIncrementAmount.klass, "initialize", VALUEFUNC(_wrap_new_MinPriceIncrementAmount), -1);
  cMinPriceIncrementAmount.mark = 0;
  cMinPriceIncrementAmount.destroy = (void (*)(void *)) free_FIX_MinPriceIncrementAmount;
  cMinPriceIncrementAmount.trackObjects = 0;
  
  cUnderlyingPayAmount.klass = rb_define_class_under(mQuickfix, "UnderlyingPayAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPayAmount, (void *) &cUnderlyingPayAmount);
  rb_define_alloc_func(cUnderlyingPayAmount.klass, _wrap_UnderlyingPayAmount_allocate);
  rb_define_method(cUnderlyingPayAmount.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPayAmount), -1);
  cUnderlyingPayAmount.mark = 0;
  cUnderlyingPayAmount.destroy = (void (*)(void *)) free_FIX_UnderlyingPayAmount;
  cUnderlyingPayAmount.trackObjects = 0;
  
  cSettlPartySubID.klass = rb_define_class_under(mQuickfix, "SettlPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartySubID, (void *) &cSettlPartySubID);
  rb_define_alloc_func(cSettlPartySubID.klass, _wrap_SettlPartySubID_allocate);
  rb_define_method(cSettlPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartySubID), -1);
  cSettlPartySubID.mark = 0;
  cSettlPartySubID.destroy = (void (*)(void *)) free_FIX_SettlPartySubID;
  cSettlPartySubID.trackObjects = 0;
  
  cAllocNetMoney.klass = rb_define_class_under(mQuickfix, "AllocNetMoney", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocNetMoney, (void *) &cAllocNetMoney);
  rb_define_alloc_func(cAllocNetMoney.klass, _wrap_AllocNetMoney_allocate);
  rb_define_method(cAllocNetMoney.klass, "initialize", VALUEFUNC(_wrap_new_AllocNetMoney), -1);
  cAllocNetMoney.mark = 0;
  cAllocNetMoney.destroy = (void (*)(void *)) free_FIX_AllocNetMoney;
  cAllocNetMoney.trackObjects = 0;
  
  cUnderlyingMaturityDay.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityDay", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityDay, (void *) &cUnderlyingMaturityDay);
  rb_define_alloc_func(cUnderlyingMaturityDay.klass, _wrap_UnderlyingMaturityDay_allocate);
  rb_define_method(cUnderlyingMaturityDay.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityDay), -1);
  cUnderlyingMaturityDay.mark = 0;
  cUnderlyingMaturityDay.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityDay;
  cUnderlyingMaturityDay.trackObjects = 0;
  
  cNetworkResponseID.klass = rb_define_class_under(mQuickfix, "NetworkResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkResponseID, (void *) &cNetworkResponseID);
  rb_define_alloc_func(cNetworkResponseID.klass, _wrap_NetworkResponseID_allocate);
  rb_define_method(cNetworkResponseID.klass, "initialize", VALUEFUNC(_wrap_new_NetworkResponseID), -1);
  cNetworkResponseID.mark = 0;
  cNetworkResponseID.destroy = (void (*)(void *)) free_FIX_NetworkResponseID;
  cNetworkResponseID.trackObjects = 0;
  
  cNumBidders.klass = rb_define_class_under(mQuickfix, "NumBidders", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NumBidders, (void *) &cNumBidders);
  rb_define_alloc_func(cNumBidders.klass, _wrap_NumBidders_allocate);
  rb_define_method(cNumBidders.klass, "initialize", VALUEFUNC(_wrap_new_NumBidders), -1);
  cNumBidders.mark = 0;
  cNumBidders.destroy = (void (*)(void *)) free_FIX_NumBidders;
  cNumBidders.trackObjects = 0;
  
  cAllocAcctIDSource.klass = rb_define_class_under(mQuickfix, "AllocAcctIDSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAcctIDSource, (void *) &cAllocAcctIDSource);
  rb_define_alloc_func(cAllocAcctIDSource.klass, _wrap_AllocAcctIDSource_allocate);
  rb_define_method(cAllocAcctIDSource.klass, "initialize", VALUEFUNC(_wrap_new_AllocAcctIDSource), -1);
  cAllocAcctIDSource.mark = 0;
  cAllocAcctIDSource.destroy = (void (*)(void *)) free_FIX_AllocAcctIDSource;
  cAllocAcctIDSource.trackObjects = 0;
  
  cAllocAvgPx.klass = rb_define_class_under(mQuickfix, "AllocAvgPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocAvgPx, (void *) &cAllocAvgPx);
  rb_define_alloc_func(cAllocAvgPx.klass, _wrap_AllocAvgPx_allocate);
  rb_define_method(cAllocAvgPx.klass, "initialize", VALUEFUNC(_wrap_new_AllocAvgPx), -1);
  cAllocAvgPx.mark = 0;
  cAllocAvgPx.destroy = (void (*)(void *)) free_FIX_AllocAvgPx;
  cAllocAvgPx.trackObjects = 0;
  
  cSecuritySettlAgentCode.klass = rb_define_class_under(mQuickfix, "SecuritySettlAgentCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecuritySettlAgentCode, (void *) &cSecuritySettlAgentCode);
  rb_define_alloc_func(cSecuritySettlAgentCode.klass, _wrap_SecuritySettlAgentCode_allocate);
  rb_define_method(cSecuritySettlAgentCode.klass, "initialize", VALUEFUNC(_wrap_new_SecuritySettlAgentCode), -1);
  cSecuritySettlAgentCode.mark = 0;
  cSecuritySettlAgentCode.destroy = (void (*)(void *)) free_FIX_SecuritySettlAgentCode;
  cSecuritySettlAgentCode.trackObjects = 0;
  
  cNoDistribInsts.klass = rb_define_class_under(mQuickfix, "NoDistribInsts", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDistribInsts, (void *) &cNoDistribInsts);
  rb_define_alloc_func(cNoDistribInsts.klass, _wrap_NoDistribInsts_allocate);
  rb_define_method(cNoDistribInsts.klass, "initialize", VALUEFUNC(_wrap_new_NoDistribInsts), -1);
  cNoDistribInsts.mark = 0;
  cNoDistribInsts.destroy = (void (*)(void *)) free_FIX_NoDistribInsts;
  cNoDistribInsts.trackObjects = 0;
  
  cCustDirectedOrder.klass = rb_define_class_under(mQuickfix, "CustDirectedOrder", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CustDirectedOrder, (void *) &cCustDirectedOrder);
  rb_define_alloc_func(cCustDirectedOrder.klass, _wrap_CustDirectedOrder_allocate);
  rb_define_method(cCustDirectedOrder.klass, "initialize", VALUEFUNC(_wrap_new_CustDirectedOrder), -1);
  cCustDirectedOrder.mark = 0;
  cCustDirectedOrder.destroy = (void (*)(void *)) free_FIX_CustDirectedOrder;
  cCustDirectedOrder.trackObjects = 0;
  
  cFairValue.klass = rb_define_class_under(mQuickfix, "FairValue", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FairValue, (void *) &cFairValue);
  rb_define_alloc_func(cFairValue.klass, _wrap_FairValue_allocate);
  rb_define_method(cFairValue.klass, "initialize", VALUEFUNC(_wrap_new_FairValue), -1);
  cFairValue.mark = 0;
  cFairValue.destroy = (void (*)(void *)) free_FIX_FairValue;
  cFairValue.trackObjects = 0;
  
  cNoStrikes.klass = rb_define_class_under(mQuickfix, "NoStrikes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStrikes, (void *) &cNoStrikes);
  rb_define_alloc_func(cNoStrikes.klass, _wrap_NoStrikes_allocate);
  rb_define_method(cNoStrikes.klass, "initialize", VALUEFUNC(_wrap_new_NoStrikes), -1);
  cNoStrikes.mark = 0;
  cNoStrikes.destroy = (void (*)(void *)) free_FIX_NoStrikes;
  cNoStrikes.trackObjects = 0;
  
  cEncodedSecurityListDescLen.klass = rb_define_class_under(mQuickfix, "EncodedSecurityListDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityListDescLen, (void *) &cEncodedSecurityListDescLen);
  rb_define_alloc_func(cEncodedSecurityListDescLen.klass, _wrap_EncodedSecurityListDescLen_allocate);
  rb_define_method(cEncodedSecurityListDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityListDescLen), -1);
  cEncodedSecurityListDescLen.mark = 0;
  cEncodedSecurityListDescLen.destroy = (void (*)(void *)) free_FIX_EncodedSecurityListDescLen;
  cEncodedSecurityListDescLen.trackObjects = 0;
  
  cLegExerciseStyle.klass = rb_define_class_under(mQuickfix, "LegExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegExerciseStyle, (void *) &cLegExerciseStyle);
  rb_define_alloc_func(cLegExerciseStyle.klass, _wrap_LegExerciseStyle_allocate);
  rb_define_method(cLegExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_LegExerciseStyle), -1);
  cLegExerciseStyle.mark = 0;
  cLegExerciseStyle.destroy = (void (*)(void *)) free_FIX_LegExerciseStyle;
  cLegExerciseStyle.trackObjects = 0;
  
  cDerivativeSymbolSfx.klass = rb_define_class_under(mQuickfix, "DerivativeSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSymbolSfx, (void *) &cDerivativeSymbolSfx);
  rb_define_alloc_func(cDerivativeSymbolSfx.klass, _wrap_DerivativeSymbolSfx_allocate);
  rb_define_method(cDerivativeSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSymbolSfx), -1);
  cDerivativeSymbolSfx.mark = 0;
  cDerivativeSymbolSfx.destroy = (void (*)(void *)) free_FIX_DerivativeSymbolSfx;
  cDerivativeSymbolSfx.trackObjects = 0;
  
  cNestedInstrAttribType.klass = rb_define_class_under(mQuickfix, "NestedInstrAttribType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NestedInstrAttribType, (void *) &cNestedInstrAttribType);
  rb_define_alloc_func(cNestedInstrAttribType.klass, _wrap_NestedInstrAttribType_allocate);
  rb_define_method(cNestedInstrAttribType.klass, "initialize", VALUEFUNC(_wrap_new_NestedInstrAttribType), -1);
  cNestedInstrAttribType.mark = 0;
  cNestedInstrAttribType.destroy = (void (*)(void *)) free_FIX_NestedInstrAttribType;
  cNestedInstrAttribType.trackObjects = 0;
  
  cContraTrader.klass = rb_define_class_under(mQuickfix, "ContraTrader", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraTrader, (void *) &cContraTrader);
  rb_define_alloc_func(cContraTrader.klass, _wrap_ContraTrader_allocate);
  rb_define_method(cContraTrader.klass, "initialize", VALUEFUNC(_wrap_new_ContraTrader), -1);
  cContraTrader.mark = 0;
  cContraTrader.destroy = (void (*)(void *)) free_FIX_ContraTrader;
  cContraTrader.trackObjects = 0;
  
  cRiskInstrumentSettlType.klass = rb_define_class_under(mQuickfix, "RiskInstrumentSettlType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskInstrumentSettlType, (void *) &cRiskInstrumentSettlType);
  rb_define_alloc_func(cRiskInstrumentSettlType.klass, _wrap_RiskInstrumentSettlType_allocate);
  rb_define_method(cRiskInstrumentSettlType.klass, "initialize", VALUEFUNC(_wrap_new_RiskInstrumentSettlType), -1);
  cRiskInstrumentSettlType.mark = 0;
  cRiskInstrumentSettlType.destroy = (void (*)(void *)) free_FIX_RiskInstrumentSettlType;
  cRiskInstrumentSettlType.trackObjects = 0;
  
  cMDSecSize.klass = rb_define_class_under(mQuickfix, "MDSecSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDSecSize, (void *) &cMDSecSize);
  rb_define_alloc_func(cMDSecSize.klass, _wrap_MDSecSize_allocate);
  rb_define_method(cMDSecSize.klass, "initialize", VALUEFUNC(_wrap_new_MDSecSize), -1);
  cMDSecSize.mark = 0;
  cMDSecSize.destroy = (void (*)(void *)) free_FIX_MDSecSize;
  cMDSecSize.trackObjects = 0;
  
  cNoOfSecSizes.klass = rb_define_class_under(mQuickfix, "NoOfSecSizes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOfSecSizes, (void *) &cNoOfSecSizes);
  rb_define_alloc_func(cNoOfSecSizes.klass, _wrap_NoOfSecSizes_allocate);
  rb_define_method(cNoOfSecSizes.klass, "initialize", VALUEFUNC(_wrap_new_NoOfSecSizes), -1);
  cNoOfSecSizes.mark = 0;
  cNoOfSecSizes.destroy = (void (*)(void *)) free_FIX_NoOfSecSizes;
  cNoOfSecSizes.trackObjects = 0;
  
  cCollAction.klass = rb_define_class_under(mQuickfix, "CollAction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAction, (void *) &cCollAction);
  rb_define_alloc_func(cCollAction.klass, _wrap_CollAction_allocate);
  rb_define_method(cCollAction.klass, "initialize", VALUEFUNC(_wrap_new_CollAction), -1);
  cCollAction.mark = 0;
  cCollAction.destroy = (void (*)(void *)) free_FIX_CollAction;
  cCollAction.trackObjects = 0;
  
  cUnderlyingLastQty.klass = rb_define_class_under(mQuickfix, "UnderlyingLastQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLastQty, (void *) &cUnderlyingLastQty);
  rb_define_alloc_func(cUnderlyingLastQty.klass, _wrap_UnderlyingLastQty_allocate);
  rb_define_method(cUnderlyingLastQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLastQty), -1);
  cUnderlyingLastQty.mark = 0;
  cUnderlyingLastQty.destroy = (void (*)(void *)) free_FIX_UnderlyingLastQty;
  cUnderlyingLastQty.trackObjects = 0;
  
  cPossDupFlag.klass = rb_define_class_under(mQuickfix, "PossDupFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PossDupFlag, (void *) &cPossDupFlag);
  rb_define_alloc_func(cPossDupFlag.klass, _wrap_PossDupFlag_allocate);
  rb_define_method(cPossDupFlag.klass, "initialize", VALUEFUNC(_wrap_new_PossDupFlag), -1);
  cPossDupFlag.mark = 0;
  cPossDupFlag.destroy = (void (*)(void *)) free_FIX_PossDupFlag;
  cPossDupFlag.trackObjects = 0;
  
  cListStatusType.klass = rb_define_class_under(mQuickfix, "ListStatusType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListStatusType, (void *) &cListStatusType);
  rb_define_alloc_func(cListStatusType.klass, _wrap_ListStatusType_allocate);
  rb_define_method(cListStatusType.klass, "initialize", VALUEFUNC(_wrap_new_ListStatusType), -1);
  cListStatusType.mark = 0;
  cListStatusType.destroy = (void (*)(void *)) free_FIX_ListStatusType;
  cListStatusType.trackObjects = 0;
  
  cSideFillStationCd.klass = rb_define_class_under(mQuickfix, "SideFillStationCd", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SideFillStationCd, (void *) &cSideFillStationCd);
  rb_define_alloc_func(cSideFillStationCd.klass, _wrap_SideFillStationCd_allocate);
  rb_define_method(cSideFillStationCd.klass, "initialize", VALUEFUNC(_wrap_new_SideFillStationCd), -1);
  cSideFillStationCd.mark = 0;
  cSideFillStationCd.destroy = (void (*)(void *)) free_FIX_SideFillStationCd;
  cSideFillStationCd.trackObjects = 0;
  
  cStatusText.klass = rb_define_class_under(mQuickfix, "StatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StatusText, (void *) &cStatusText);
  rb_define_alloc_func(cStatusText.klass, _wrap_StatusText_allocate);
  rb_define_method(cStatusText.klass, "initialize", VALUEFUNC(_wrap_new_StatusText), -1);
  cStatusText.mark = 0;
  cStatusText.destroy = (void (*)(void *)) free_FIX_StatusText;
  cStatusText.trackObjects = 0;
  
  cBasisFeatureDate.klass = rb_define_class_under(mQuickfix, "BasisFeatureDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BasisFeatureDate, (void *) &cBasisFeatureDate);
  rb_define_alloc_func(cBasisFeatureDate.klass, _wrap_BasisFeatureDate_allocate);
  rb_define_method(cBasisFeatureDate.klass, "initialize", VALUEFUNC(_wrap_new_BasisFeatureDate), -1);
  cBasisFeatureDate.mark = 0;
  cBasisFeatureDate.destroy = (void (*)(void *)) free_FIX_BasisFeatureDate;
  cBasisFeatureDate.trackObjects = 0;
  
  cXmlDataLen.klass = rb_define_class_under(mQuickfix, "XmlDataLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__XmlDataLen, (void *) &cXmlDataLen);
  rb_define_alloc_func(cXmlDataLen.klass, _wrap_XmlDataLen_allocate);
  rb_define_method(cXmlDataLen.klass, "initialize", VALUEFUNC(_wrap_new_XmlDataLen), -1);
  cXmlDataLen.mark = 0;
  cXmlDataLen.destroy = (void (*)(void *)) free_FIX_XmlDataLen;
  cXmlDataLen.trackObjects = 0;
  
  cUnderlyingMaturityDate.klass = rb_define_class_under(mQuickfix, "UnderlyingMaturityDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingMaturityDate, (void *) &cUnderlyingMaturityDate);
  rb_define_alloc_func(cUnderlyingMaturityDate.klass, _wrap_UnderlyingMaturityDate_allocate);
  rb_define_method(cUnderlyingMaturityDate.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingMaturityDate), -1);
  cUnderlyingMaturityDate.mark = 0;
  cUnderlyingMaturityDate.destroy = (void (*)(void *)) free_FIX_UnderlyingMaturityDate;
  cUnderlyingMaturityDate.trackObjects = 0;
  
  cGapFillFlag.klass = rb_define_class_under(mQuickfix, "GapFillFlag", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__GapFillFlag, (void *) &cGapFillFlag);
  rb_define_alloc_func(cGapFillFlag.klass, _wrap_GapFillFlag_allocate);
  rb_define_method(cGapFillFlag.klass, "initialize", VALUEFUNC(_wrap_new_GapFillFlag), -1);
  cGapFillFlag.mark = 0;
  cGapFillFlag.destroy = (void (*)(void *)) free_FIX_GapFillFlag;
  cGapFillFlag.trackObjects = 0;
  
  cRefApplExtID.klass = rb_define_class_under(mQuickfix, "RefApplExtID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplExtID, (void *) &cRefApplExtID);
  rb_define_alloc_func(cRefApplExtID.klass, _wrap_RefApplExtID_allocate);
  rb_define_method(cRefApplExtID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplExtID), -1);
  cRefApplExtID.mark = 0;
  cRefApplExtID.destroy = (void (*)(void *)) free_FIX_RefApplExtID;
  cRefApplExtID.trackObjects = 0;
  
  cRefApplID.klass = rb_define_class_under(mQuickfix, "RefApplID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefApplID, (void *) &cRefApplID);
  rb_define_alloc_func(cRefApplID.klass, _wrap_RefApplID_allocate);
  rb_define_method(cRefApplID.klass, "initialize", VALUEFUNC(_wrap_new_RefApplID), -1);
  cRefApplID.mark = 0;
  cRefApplID.destroy = (void (*)(void *)) free_FIX_RefApplID;
  cRefApplID.trackObjects = 0;
  
  cNoTradingSessionRules.klass = rb_define_class_under(mQuickfix, "NoTradingSessionRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTradingSessionRules, (void *) &cNoTradingSessionRules);
  rb_define_alloc_func(cNoTradingSessionRules.klass, _wrap_NoTradingSessionRules_allocate);
  rb_define_method(cNoTradingSessionRules.klass, "initialize", VALUEFUNC(_wrap_new_NoTradingSessionRules), -1);
  cNoTradingSessionRules.mark = 0;
  cNoTradingSessionRules.destroy = (void (*)(void *)) free_FIX_NoTradingSessionRules;
  cNoTradingSessionRules.trackObjects = 0;
  
  cSwapPoints.klass = rb_define_class_under(mQuickfix, "SwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SwapPoints, (void *) &cSwapPoints);
  rb_define_alloc_func(cSwapPoints.klass, _wrap_SwapPoints_allocate);
  rb_define_method(cSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_SwapPoints), -1);
  cSwapPoints.mark = 0;
  cSwapPoints.destroy = (void (*)(void *)) free_FIX_SwapPoints;
  cSwapPoints.trackObjects = 0;
  
  cTargetStrategyParameters.klass = rb_define_class_under(mQuickfix, "TargetStrategyParameters", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetStrategyParameters, (void *) &cTargetStrategyParameters);
  rb_define_alloc_func(cTargetStrategyParameters.klass, _wrap_TargetStrategyParameters_allocate);
  rb_define_method(cTargetStrategyParameters.klass, "initialize", VALUEFUNC(_wrap_new_TargetStrategyParameters), -1);
  cTargetStrategyParameters.mark = 0;
  cTargetStrategyParameters.destroy = (void (*)(void *)) free_FIX_TargetStrategyParameters;
  cTargetStrategyParameters.trackObjects = 0;
  
  cLastForwardPoints.klass = rb_define_class_under(mQuickfix, "LastForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastForwardPoints, (void *) &cLastForwardPoints);
  rb_define_alloc_func(cLastForwardPoints.klass, _wrap_LastForwardPoints_allocate);
  rb_define_method(cLastForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LastForwardPoints), -1);
  cLastForwardPoints.mark = 0;
  cLastForwardPoints.destroy = (void (*)(void *)) free_FIX_LastForwardPoints;
  cLastForwardPoints.trackObjects = 0;
  
  cYieldRedemptionDate.klass = rb_define_class_under(mQuickfix, "YieldRedemptionDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__YieldRedemptionDate, (void *) &cYieldRedemptionDate);
  rb_define_alloc_func(cYieldRedemptionDate.klass, _wrap_YieldRedemptionDate_allocate);
  rb_define_method(cYieldRedemptionDate.klass, "initialize", VALUEFUNC(_wrap_new_YieldRedemptionDate), -1);
  cYieldRedemptionDate.mark = 0;
  cYieldRedemptionDate.destroy = (void (*)(void *)) free_FIX_YieldRedemptionDate;
  cYieldRedemptionDate.trackObjects = 0;
  
  cRelationshipRiskSecurityID.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityID, (void *) &cRelationshipRiskSecurityID);
  rb_define_alloc_func(cRelationshipRiskSecurityID.klass, _wrap_RelationshipRiskSecurityID_allocate);
  rb_define_method(cRelationshipRiskSecurityID.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityID), -1);
  cRelationshipRiskSecurityID.mark = 0;
  cRelationshipRiskSecurityID.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityID;
  cRelationshipRiskSecurityID.trackObjects = 0;
  
  cNoSettlDetails.klass = rb_define_class_under(mQuickfix, "NoSettlDetails", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSettlDetails, (void *) &cNoSettlDetails);
  rb_define_alloc_func(cNoSettlDetails.klass, _wrap_NoSettlDetails_allocate);
  rb_define_method(cNoSettlDetails.klass, "initialize", VALUEFUNC(_wrap_new_NoSettlDetails), -1);
  cNoSettlDetails.mark = 0;
  cNoSettlDetails.destroy = (void (*)(void *)) free_FIX_NoSettlDetails;
  cNoSettlDetails.trackObjects = 0;
  
  cTradeHandlingInstr.klass = rb_define_class_under(mQuickfix, "TradeHandlingInstr", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeHandlingInstr, (void *) &cTradeHandlingInstr);
  rb_define_alloc_func(cTradeHandlingInstr.klass, _wrap_TradeHandlingInstr_allocate);
  rb_define_method(cTradeHandlingInstr.klass, "initialize", VALUEFUNC(_wrap_new_TradeHandlingInstr), -1);
  cTradeHandlingInstr.mark = 0;
  cTradeHandlingInstr.destroy = (void (*)(void *)) free_FIX_TradeHandlingInstr;
  cTradeHandlingInstr.trackObjects = 0;
  
  cCashSettlAgentCode.klass = rb_define_class_under(mQuickfix, "CashSettlAgentCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentCode, (void *) &cCashSettlAgentCode);
  rb_define_alloc_func(cCashSettlAgentCode.klass, _wrap_CashSettlAgentCode_allocate);
  rb_define_method(cCashSettlAgentCode.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentCode), -1);
  cCashSettlAgentCode.mark = 0;
  cCashSettlAgentCode.destroy = (void (*)(void *)) free_FIX_CashSettlAgentCode;
  cCashSettlAgentCode.trackObjects = 0;
  
  cLegPriceType.klass = rb_define_class_under(mQuickfix, "LegPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegPriceType, (void *) &cLegPriceType);
  rb_define_alloc_func(cLegPriceType.klass, _wrap_LegPriceType_allocate);
  rb_define_method(cLegPriceType.klass, "initialize", VALUEFUNC(_wrap_new_LegPriceType), -1);
  cLegPriceType.mark = 0;
  cLegPriceType.destroy = (void (*)(void *)) free_FIX_LegPriceType;
  cLegPriceType.trackObjects = 0;
  
  cEncodedListExecInstLen.klass = rb_define_class_under(mQuickfix, "EncodedListExecInstLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListExecInstLen, (void *) &cEncodedListExecInstLen);
  rb_define_alloc_func(cEncodedListExecInstLen.klass, _wrap_EncodedListExecInstLen_allocate);
  rb_define_method(cEncodedListExecInstLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListExecInstLen), -1);
  cEncodedListExecInstLen.mark = 0;
  cEncodedListExecInstLen.destroy = (void (*)(void *)) free_FIX_EncodedListExecInstLen;
  cEncodedListExecInstLen.trackObjects = 0;
  
  cTradSesMethod.klass = rb_define_class_under(mQuickfix, "TradSesMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradSesMethod, (void *) &cTradSesMethod);
  rb_define_alloc_func(cTradSesMethod.klass, _wrap_TradSesMethod_allocate);
  rb_define_method(cTradSesMethod.klass, "initialize", VALUEFUNC(_wrap_new_TradSesMethod), -1);
  cTradSesMethod.mark = 0;
  cTradSesMethod.destroy = (void (*)(void *)) free_FIX_TradSesMethod;
  cTradSesMethod.trackObjects = 0;
  
  cRiskLimitCurrency.klass = rb_define_class_under(mQuickfix, "RiskLimitCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskLimitCurrency, (void *) &cRiskLimitCurrency);
  rb_define_alloc_func(cRiskLimitCurrency.klass, _wrap_RiskLimitCurrency_allocate);
  rb_define_method(cRiskLimitCurrency.klass, "initialize", VALUEFUNC(_wrap_new_RiskLimitCurrency), -1);
  cRiskLimitCurrency.mark = 0;
  cRiskLimitCurrency.destroy = (void (*)(void *)) free_FIX_RiskLimitCurrency;
  cRiskLimitCurrency.trackObjects = 0;
  
  cPartyDetailsListRequestID.klass = rb_define_class_under(mQuickfix, "PartyDetailsListRequestID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyDetailsListRequestID, (void *) &cPartyDetailsListRequestID);
  rb_define_alloc_func(cPartyDetailsListRequestID.klass, _wrap_PartyDetailsListRequestID_allocate);
  rb_define_method(cPartyDetailsListRequestID.klass, "initialize", VALUEFUNC(_wrap_new_PartyDetailsListRequestID), -1);
  cPartyDetailsListRequestID.mark = 0;
  cPartyDetailsListRequestID.destroy = (void (*)(void *)) free_FIX_PartyDetailsListRequestID;
  cPartyDetailsListRequestID.trackObjects = 0;
  
  cAgreementID.klass = rb_define_class_under(mQuickfix, "AgreementID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AgreementID, (void *) &cAgreementID);
  rb_define_alloc_func(cAgreementID.klass, _wrap_AgreementID_allocate);
  rb_define_method(cAgreementID.klass, "initialize", VALUEFUNC(_wrap_new_AgreementID), -1);
  cAgreementID.mark = 0;
  cAgreementID.destroy = (void (*)(void *)) free_FIX_AgreementID;
  cAgreementID.trackObjects = 0;
  
  cCashDistribCurr.klass = rb_define_class_under(mQuickfix, "CashDistribCurr", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashDistribCurr, (void *) &cCashDistribCurr);
  rb_define_alloc_func(cCashDistribCurr.klass, _wrap_CashDistribCurr_allocate);
  rb_define_method(cCashDistribCurr.klass, "initialize", VALUEFUNC(_wrap_new_CashDistribCurr), -1);
  cCashDistribCurr.mark = 0;
  cCashDistribCurr.destroy = (void (*)(void *)) free_FIX_CashDistribCurr;
  cCashDistribCurr.trackObjects = 0;
  
  cBidPx.klass = rb_define_class_under(mQuickfix, "BidPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidPx, (void *) &cBidPx);
  rb_define_alloc_func(cBidPx.klass, _wrap_BidPx_allocate);
  rb_define_method(cBidPx.klass, "initialize", VALUEFUNC(_wrap_new_BidPx), -1);
  cBidPx.mark = 0;
  cBidPx.destroy = (void (*)(void *)) free_FIX_BidPx;
  cBidPx.trackObjects = 0;
  
  cTradeType.klass = rb_define_class_under(mQuickfix, "TradeType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeType, (void *) &cTradeType);
  rb_define_alloc_func(cTradeType.klass, _wrap_TradeType_allocate);
  rb_define_method(cTradeType.klass, "initialize", VALUEFUNC(_wrap_new_TradeType), -1);
  cTradeType.mark = 0;
  cTradeType.destroy = (void (*)(void *)) free_FIX_TradeType;
  cTradeType.trackObjects = 0;
  
  cEncodedSecurityDescLen.klass = rb_define_class_under(mQuickfix, "EncodedSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedSecurityDescLen, (void *) &cEncodedSecurityDescLen);
  rb_define_alloc_func(cEncodedSecurityDescLen.klass, _wrap_EncodedSecurityDescLen_allocate);
  rb_define_method(cEncodedSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedSecurityDescLen), -1);
  cEncodedSecurityDescLen.mark = 0;
  cEncodedSecurityDescLen.destroy = (void (*)(void *)) free_FIX_EncodedSecurityDescLen;
  cEncodedSecurityDescLen.trackObjects = 0;
  
  cComplexEventCondition.klass = rb_define_class_under(mQuickfix, "ComplexEventCondition", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventCondition, (void *) &cComplexEventCondition);
  rb_define_alloc_func(cComplexEventCondition.klass, _wrap_ComplexEventCondition_allocate);
  rb_define_method(cComplexEventCondition.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventCondition), -1);
  cComplexEventCondition.mark = 0;
  cComplexEventCondition.destroy = (void (*)(void *)) free_FIX_ComplexEventCondition;
  cComplexEventCondition.trackObjects = 0;
  
  cEncryptedPasswordMethod.klass = rb_define_class_under(mQuickfix, "EncryptedPasswordMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncryptedPasswordMethod, (void *) &cEncryptedPasswordMethod);
  rb_define_alloc_func(cEncryptedPasswordMethod.klass, _wrap_EncryptedPasswordMethod_allocate);
  rb_define_method(cEncryptedPasswordMethod.klass, "initialize", VALUEFUNC(_wrap_new_EncryptedPasswordMethod), -1);
  cEncryptedPasswordMethod.mark = 0;
  cEncryptedPasswordMethod.destroy = (void (*)(void *)) free_FIX_EncryptedPasswordMethod;
  cEncryptedPasswordMethod.trackObjects = 0;
  
  cDerivativeSecurityAltID.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityAltID, (void *) &cDerivativeSecurityAltID);
  rb_define_alloc_func(cDerivativeSecurityAltID.klass, _wrap_DerivativeSecurityAltID_allocate);
  rb_define_method(cDerivativeSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityAltID), -1);
  cDerivativeSecurityAltID.mark = 0;
  cDerivativeSecurityAltID.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityAltID;
  cDerivativeSecurityAltID.trackObjects = 0;
  
  cTotNoAccQuotes.klass = rb_define_class_under(mQuickfix, "TotNoAccQuotes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoAccQuotes, (void *) &cTotNoAccQuotes);
  rb_define_alloc_func(cTotNoAccQuotes.klass, _wrap_TotNoAccQuotes_allocate);
  rb_define_method(cTotNoAccQuotes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoAccQuotes), -1);
  cTotNoAccQuotes.mark = 0;
  cTotNoAccQuotes.destroy = (void (*)(void *)) free_FIX_TotNoAccQuotes;
  cTotNoAccQuotes.trackObjects = 0;
  
  cTimeBracket.klass = rb_define_class_under(mQuickfix, "TimeBracket", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeBracket, (void *) &cTimeBracket);
  rb_define_alloc_func(cTimeBracket.klass, _wrap_TimeBracket_allocate);
  rb_define_method(cTimeBracket.klass, "initialize", VALUEFUNC(_wrap_new_TimeBracket), -1);
  cTimeBracket.mark = 0;
  cTimeBracket.destroy = (void (*)(void *)) free_FIX_TimeBracket;
  cTimeBracket.trackObjects = 0;
  
  cNoAllocs.klass = rb_define_class_under(mQuickfix, "NoAllocs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoAllocs, (void *) &cNoAllocs);
  rb_define_alloc_func(cNoAllocs.klass, _wrap_NoAllocs_allocate);
  rb_define_method(cNoAllocs.klass, "initialize", VALUEFUNC(_wrap_new_NoAllocs), -1);
  cNoAllocs.mark = 0;
  cNoAllocs.destroy = (void (*)(void *)) free_FIX_NoAllocs;
  cNoAllocs.trackObjects = 0;
  
  cUnderlyingProduct.klass = rb_define_class_under(mQuickfix, "UnderlyingProduct", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingProduct, (void *) &cUnderlyingProduct);
  rb_define_alloc_func(cUnderlyingProduct.klass, _wrap_UnderlyingProduct_allocate);
  rb_define_method(cUnderlyingProduct.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingProduct), -1);
  cUnderlyingProduct.mark = 0;
  cUnderlyingProduct.destroy = (void (*)(void *)) free_FIX_UnderlyingProduct;
  cUnderlyingProduct.trackObjects = 0;
  
  cBenchmarkCurveName.klass = rb_define_class_under(mQuickfix, "BenchmarkCurveName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkCurveName, (void *) &cBenchmarkCurveName);
  rb_define_alloc_func(cBenchmarkCurveName.klass, _wrap_BenchmarkCurveName_allocate);
  rb_define_method(cBenchmarkCurveName.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkCurveName), -1);
  cBenchmarkCurveName.mark = 0;
  cBenchmarkCurveName.destroy = (void (*)(void *)) free_FIX_BenchmarkCurveName;
  cBenchmarkCurveName.trackObjects = 0;
  
  cUnderlyingSymbolSfx.klass = rb_define_class_under(mQuickfix, "UnderlyingSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSymbolSfx, (void *) &cUnderlyingSymbolSfx);
  rb_define_alloc_func(cUnderlyingSymbolSfx.klass, _wrap_UnderlyingSymbolSfx_allocate);
  rb_define_method(cUnderlyingSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSymbolSfx), -1);
  cUnderlyingSymbolSfx.mark = 0;
  cUnderlyingSymbolSfx.destroy = (void (*)(void *)) free_FIX_UnderlyingSymbolSfx;
  cUnderlyingSymbolSfx.trackObjects = 0;
  
  cStrikePriceBoundaryPrecision.klass = rb_define_class_under(mQuickfix, "StrikePriceBoundaryPrecision", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision, (void *) &cStrikePriceBoundaryPrecision);
  rb_define_alloc_func(cStrikePriceBoundaryPrecision.klass, _wrap_StrikePriceBoundaryPrecision_allocate);
  rb_define_method(cStrikePriceBoundaryPrecision.klass, "initialize", VALUEFUNC(_wrap_new_StrikePriceBoundaryPrecision), -1);
  cStrikePriceBoundaryPrecision.mark = 0;
  cStrikePriceBoundaryPrecision.destroy = (void (*)(void *)) free_FIX_StrikePriceBoundaryPrecision;
  cStrikePriceBoundaryPrecision.trackObjects = 0;
  
  cQuoteSetID.klass = rb_define_class_under(mQuickfix, "QuoteSetID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteSetID, (void *) &cQuoteSetID);
  rb_define_alloc_func(cQuoteSetID.klass, _wrap_QuoteSetID_allocate);
  rb_define_method(cQuoteSetID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteSetID), -1);
  cQuoteSetID.mark = 0;
  cQuoteSetID.destroy = (void (*)(void *)) free_FIX_QuoteSetID;
  cQuoteSetID.trackObjects = 0;
  
  cCashMargin.klass = rb_define_class_under(mQuickfix, "CashMargin", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashMargin, (void *) &cCashMargin);
  rb_define_alloc_func(cCashMargin.klass, _wrap_CashMargin_allocate);
  rb_define_method(cCashMargin.klass, "initialize", VALUEFUNC(_wrap_new_CashMargin), -1);
  cCashMargin.mark = 0;
  cCashMargin.destroy = (void (*)(void *)) free_FIX_CashMargin;
  cCashMargin.trackObjects = 0;
  
  cSettlObligTransType.klass = rb_define_class_under(mQuickfix, "SettlObligTransType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlObligTransType, (void *) &cSettlObligTransType);
  rb_define_alloc_func(cSettlObligTransType.klass, _wrap_SettlObligTransType_allocate);
  rb_define_method(cSettlObligTransType.klass, "initialize", VALUEFUNC(_wrap_new_SettlObligTransType), -1);
  cSettlObligTransType.mark = 0;
  cSettlObligTransType.destroy = (void (*)(void *)) free_FIX_SettlObligTransType;
  cSettlObligTransType.trackObjects = 0;
  
  cLegNumber.klass = rb_define_class_under(mQuickfix, "LegNumber", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegNumber, (void *) &cLegNumber);
  rb_define_alloc_func(cLegNumber.klass, _wrap_LegNumber_allocate);
  rb_define_method(cLegNumber.klass, "initialize", VALUEFUNC(_wrap_new_LegNumber), -1);
  cLegNumber.mark = 0;
  cLegNumber.destroy = (void (*)(void *)) free_FIX_LegNumber;
  cLegNumber.trackObjects = 0;
  
  cDeskOrderHandlingInst.klass = rb_define_class_under(mQuickfix, "DeskOrderHandlingInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskOrderHandlingInst, (void *) &cDeskOrderHandlingInst);
  rb_define_alloc_func(cDeskOrderHandlingInst.klass, _wrap_DeskOrderHandlingInst_allocate);
  rb_define_method(cDeskOrderHandlingInst.klass, "initialize", VALUEFUNC(_wrap_new_DeskOrderHandlingInst), -1);
  cDeskOrderHandlingInst.mark = 0;
  cDeskOrderHandlingInst.destroy = (void (*)(void *)) free_FIX_DeskOrderHandlingInst;
  cDeskOrderHandlingInst.trackObjects = 0;
  
  cSettlPartyIDSource.klass = rb_define_class_under(mQuickfix, "SettlPartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlPartyIDSource, (void *) &cSettlPartyIDSource);
  rb_define_alloc_func(cSettlPartyIDSource.klass, _wrap_SettlPartyIDSource_allocate);
  rb_define_method(cSettlPartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_SettlPartyIDSource), -1);
  cSettlPartyIDSource.mark = 0;
  cSettlPartyIDSource.destroy = (void (*)(void *)) free_FIX_SettlPartyIDSource;
  cSettlPartyIDSource.trackObjects = 0;
  
  cPriorSettlPrice.klass = rb_define_class_under(mQuickfix, "PriorSettlPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriorSettlPrice, (void *) &cPriorSettlPrice);
  rb_define_alloc_func(cPriorSettlPrice.klass, _wrap_PriorSettlPrice_allocate);
  rb_define_method(cPriorSettlPrice.klass, "initialize", VALUEFUNC(_wrap_new_PriorSettlPrice), -1);
  cPriorSettlPrice.mark = 0;
  cPriorSettlPrice.destroy = (void (*)(void *)) free_FIX_PriorSettlPrice;
  cPriorSettlPrice.trackObjects = 0;
  
  cRelationshipRiskSecurityType.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSecurityType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSecurityType, (void *) &cRelationshipRiskSecurityType);
  rb_define_alloc_func(cRelationshipRiskSecurityType.klass, _wrap_RelationshipRiskSecurityType_allocate);
  rb_define_method(cRelationshipRiskSecurityType.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSecurityType), -1);
  cRelationshipRiskSecurityType.mark = 0;
  cRelationshipRiskSecurityType.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSecurityType;
  cRelationshipRiskSecurityType.trackObjects = 0;
  
  cNotAffOrigClOrdID.klass = rb_define_class_under(mQuickfix, "NotAffOrigClOrdID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NotAffOrigClOrdID, (void *) &cNotAffOrigClOrdID);
  rb_define_alloc_func(cNotAffOrigClOrdID.klass, _wrap_NotAffOrigClOrdID_allocate);
  rb_define_method(cNotAffOrigClOrdID.klass, "initialize", VALUEFUNC(_wrap_new_NotAffOrigClOrdID), -1);
  cNotAffOrigClOrdID.mark = 0;
  cNotAffOrigClOrdID.destroy = (void (*)(void *)) free_FIX_NotAffOrigClOrdID;
  cNotAffOrigClOrdID.trackObjects = 0;
  
  cTradingSessionDesc.klass = rb_define_class_under(mQuickfix, "TradingSessionDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradingSessionDesc, (void *) &cTradingSessionDesc);
  rb_define_alloc_func(cTradingSessionDesc.klass, _wrap_TradingSessionDesc_allocate);
  rb_define_method(cTradingSessionDesc.klass, "initialize", VALUEFUNC(_wrap_new_TradingSessionDesc), -1);
  cTradingSessionDesc.mark = 0;
  cTradingSessionDesc.destroy = (void (*)(void *)) free_FIX_TradingSessionDesc;
  cTradingSessionDesc.trackObjects = 0;
  
  cDerivativeFloorPrice.klass = rb_define_class_under(mQuickfix, "DerivativeFloorPrice", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeFloorPrice, (void *) &cDerivativeFloorPrice);
  rb_define_alloc_func(cDerivativeFloorPrice.klass, _wrap_DerivativeFloorPrice_allocate);
  rb_define_method(cDerivativeFloorPrice.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeFloorPrice), -1);
  cDerivativeFloorPrice.mark = 0;
  cDerivativeFloorPrice.destroy = (void (*)(void *)) free_FIX_DerivativeFloorPrice;
  cDerivativeFloorPrice.trackObjects = 0;
  
  cDerivativeSymbol.klass = rb_define_class_under(mQuickfix, "DerivativeSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSymbol, (void *) &cDerivativeSymbol);
  rb_define_alloc_func(cDerivativeSymbol.klass, _wrap_DerivativeSymbol_allocate);
  rb_define_method(cDerivativeSymbol.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSymbol), -1);
  cDerivativeSymbol.mark = 0;
  cDerivativeSymbol.destroy = (void (*)(void *)) free_FIX_DerivativeSymbol;
  cDerivativeSymbol.trackObjects = 0;
  
  cRiskFreeRate.klass = rb_define_class_under(mQuickfix, "RiskFreeRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskFreeRate, (void *) &cRiskFreeRate);
  rb_define_alloc_func(cRiskFreeRate.klass, _wrap_RiskFreeRate_allocate);
  rb_define_method(cRiskFreeRate.klass, "initialize", VALUEFUNC(_wrap_new_RiskFreeRate), -1);
  cRiskFreeRate.mark = 0;
  cRiskFreeRate.destroy = (void (*)(void *)) free_FIX_RiskFreeRate;
  cRiskFreeRate.trackObjects = 0;
  
  cPosTransType.klass = rb_define_class_under(mQuickfix, "PosTransType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosTransType, (void *) &cPosTransType);
  rb_define_alloc_func(cPosTransType.klass, _wrap_PosTransType_allocate);
  rb_define_method(cPosTransType.klass, "initialize", VALUEFUNC(_wrap_new_PosTransType), -1);
  cPosTransType.mark = 0;
  cPosTransType.destroy = (void (*)(void *)) free_FIX_PosTransType;
  cPosTransType.trackObjects = 0;
  
  cMsgSeqNum.klass = rb_define_class_under(mQuickfix, "MsgSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MsgSeqNum, (void *) &cMsgSeqNum);
  rb_define_alloc_func(cMsgSeqNum.klass, _wrap_MsgSeqNum_allocate);
  rb_define_method(cMsgSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_MsgSeqNum), -1);
  cMsgSeqNum.mark = 0;
  cMsgSeqNum.destroy = (void (*)(void *)) free_FIX_MsgSeqNum;
  cMsgSeqNum.trackObjects = 0;
  
  cSignature.klass = rb_define_class_under(mQuickfix, "Signature", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Signature, (void *) &cSignature);
  rb_define_alloc_func(cSignature.klass, _wrap_Signature_allocate);
  rb_define_method(cSignature.klass, "initialize", VALUEFUNC(_wrap_new_Signature), -1);
  cSignature.mark = 0;
  cSignature.destroy = (void (*)(void *)) free_FIX_Signature;
  cSignature.trackObjects = 0;
  
  cSeniority.klass = rb_define_class_under(mQuickfix, "Seniority", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Seniority, (void *) &cSeniority);
  rb_define_alloc_func(cSeniority.klass, _wrap_Seniority_allocate);
  rb_define_method(cSeniority.klass, "initialize", VALUEFUNC(_wrap_new_Seniority), -1);
  cSeniority.mark = 0;
  cSeniority.destroy = (void (*)(void *)) free_FIX_Seniority;
  cSeniority.trackObjects = 0;
  
  cNoRateSources.klass = rb_define_class_under(mQuickfix, "NoRateSources", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRateSources, (void *) &cNoRateSources);
  rb_define_alloc_func(cNoRateSources.klass, _wrap_NoRateSources_allocate);
  rb_define_method(cNoRateSources.klass, "initialize", VALUEFUNC(_wrap_new_NoRateSources), -1);
  cNoRateSources.mark = 0;
  cNoRateSources.destroy = (void (*)(void *)) free_FIX_NoRateSources;
  cNoRateSources.trackObjects = 0;
  
  cPriceUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "PriceUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriceUnitOfMeasureQty, (void *) &cPriceUnitOfMeasureQty);
  rb_define_alloc_func(cPriceUnitOfMeasureQty.klass, _wrap_PriceUnitOfMeasureQty_allocate);
  rb_define_method(cPriceUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_PriceUnitOfMeasureQty), -1);
  cPriceUnitOfMeasureQty.mark = 0;
  cPriceUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_PriceUnitOfMeasureQty;
  cPriceUnitOfMeasureQty.trackObjects = 0;
  
  cCollAsgnRefID.klass = rb_define_class_under(mQuickfix, "CollAsgnRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollAsgnRefID, (void *) &cCollAsgnRefID);
  rb_define_alloc_func(cCollAsgnRefID.klass, _wrap_CollAsgnRefID_allocate);
  rb_define_method(cCollAsgnRefID.klass, "initialize", VALUEFUNC(_wrap_new_CollAsgnRefID), -1);
  cCollAsgnRefID.mark = 0;
  cCollAsgnRefID.destroy = (void (*)(void *)) free_FIX_CollAsgnRefID;
  cCollAsgnRefID.trackObjects = 0;
  
  cBuyVolume.klass = rb_define_class_under(mQuickfix, "BuyVolume", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BuyVolume, (void *) &cBuyVolume);
  rb_define_alloc_func(cBuyVolume.klass, _wrap_BuyVolume_allocate);
  rb_define_method(cBuyVolume.klass, "initialize", VALUEFUNC(_wrap_new_BuyVolume), -1);
  cBuyVolume.mark = 0;
  cBuyVolume.destroy = (void (*)(void *)) free_FIX_BuyVolume;
  cBuyVolume.trackObjects = 0;
  
  cSettlCurrFxRateCalc.klass = rb_define_class_under(mQuickfix, "SettlCurrFxRateCalc", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrFxRateCalc, (void *) &cSettlCurrFxRateCalc);
  rb_define_alloc_func(cSettlCurrFxRateCalc.klass, _wrap_SettlCurrFxRateCalc_allocate);
  rb_define_method(cSettlCurrFxRateCalc.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrFxRateCalc), -1);
  cSettlCurrFxRateCalc.mark = 0;
  cSettlCurrFxRateCalc.destroy = (void (*)(void *)) free_FIX_SettlCurrFxRateCalc;
  cSettlCurrFxRateCalc.trackObjects = 0;
  
  cPosMaintStatus.klass = rb_define_class_under(mQuickfix, "PosMaintStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintStatus, (void *) &cPosMaintStatus);
  rb_define_alloc_func(cPosMaintStatus.klass, _wrap_PosMaintStatus_allocate);
  rb_define_method(cPosMaintStatus.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintStatus), -1);
  cPosMaintStatus.mark = 0;
  cPosMaintStatus.destroy = (void (*)(void *)) free_FIX_PosMaintStatus;
  cPosMaintStatus.trackObjects = 0;
  
  cPriorSpreadIndicator.klass = rb_define_class_under(mQuickfix, "PriorSpreadIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriorSpreadIndicator, (void *) &cPriorSpreadIndicator);
  rb_define_alloc_func(cPriorSpreadIndicator.klass, _wrap_PriorSpreadIndicator_allocate);
  rb_define_method(cPriorSpreadIndicator.klass, "initialize", VALUEFUNC(_wrap_new_PriorSpreadIndicator), -1);
  cPriorSpreadIndicator.mark = 0;
  cPriorSpreadIndicator.destroy = (void (*)(void *)) free_FIX_PriorSpreadIndicator;
  cPriorSpreadIndicator.trackObjects = 0;
  
  cBenchmark.klass = rb_define_class_under(mQuickfix, "Benchmark", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Benchmark, (void *) &cBenchmark);
  rb_define_alloc_func(cBenchmark.klass, _wrap_Benchmark_allocate);
  rb_define_method(cBenchmark.klass, "initialize", VALUEFUNC(_wrap_new_Benchmark), -1);
  cBenchmark.mark = 0;
  cBenchmark.destroy = (void (*)(void *)) free_FIX_Benchmark;
  cBenchmark.trackObjects = 0;
  
  cMaturityMonthYearFormat.klass = rb_define_class_under(mQuickfix, "MaturityMonthYearFormat", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityMonthYearFormat, (void *) &cMaturityMonthYearFormat);
  rb_define_alloc_func(cMaturityMonthYearFormat.klass, _wrap_MaturityMonthYearFormat_allocate);
  rb_define_method(cMaturityMonthYearFormat.klass, "initialize", VALUEFUNC(_wrap_new_MaturityMonthYearFormat), -1);
  cMaturityMonthYearFormat.mark = 0;
  cMaturityMonthYearFormat.destroy = (void (*)(void *)) free_FIX_MaturityMonthYearFormat;
  cMaturityMonthYearFormat.trackObjects = 0;
  
  cUnderlyingTradingSessionID.klass = rb_define_class_under(mQuickfix, "UnderlyingTradingSessionID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingTradingSessionID, (void *) &cUnderlyingTradingSessionID);
  rb_define_alloc_func(cUnderlyingTradingSessionID.klass, _wrap_UnderlyingTradingSessionID_allocate);
  rb_define_method(cUnderlyingTradingSessionID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingTradingSessionID), -1);
  cUnderlyingTradingSessionID.mark = 0;
  cUnderlyingTradingSessionID.destroy = (void (*)(void *)) free_FIX_UnderlyingTradingSessionID;
  cUnderlyingTradingSessionID.trackObjects = 0;
  
  cTotNoRelatedSym.klass = rb_define_class_under(mQuickfix, "TotNoRelatedSym", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoRelatedSym, (void *) &cTotNoRelatedSym);
  rb_define_alloc_func(cTotNoRelatedSym.klass, _wrap_TotNoRelatedSym_allocate);
  rb_define_method(cTotNoRelatedSym.klass, "initialize", VALUEFUNC(_wrap_new_TotNoRelatedSym), -1);
  cTotNoRelatedSym.mark = 0;
  cTotNoRelatedSym.destroy = (void (*)(void *)) free_FIX_TotNoRelatedSym;
  cTotNoRelatedSym.trackObjects = 0;
  
  cStateOrProvinceOfIssue.klass = rb_define_class_under(mQuickfix, "StateOrProvinceOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StateOrProvinceOfIssue, (void *) &cStateOrProvinceOfIssue);
  rb_define_alloc_func(cStateOrProvinceOfIssue.klass, _wrap_StateOrProvinceOfIssue_allocate);
  rb_define_method(cStateOrProvinceOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_StateOrProvinceOfIssue), -1);
  cStateOrProvinceOfIssue.mark = 0;
  cStateOrProvinceOfIssue.destroy = (void (*)(void *)) free_FIX_StateOrProvinceOfIssue;
  cStateOrProvinceOfIssue.trackObjects = 0;
  
  cRelatedPartyAltSubID.klass = rb_define_class_under(mQuickfix, "RelatedPartyAltSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartyAltSubID, (void *) &cRelatedPartyAltSubID);
  rb_define_alloc_func(cRelatedPartyAltSubID.klass, _wrap_RelatedPartyAltSubID_allocate);
  rb_define_method(cRelatedPartyAltSubID.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartyAltSubID), -1);
  cRelatedPartyAltSubID.mark = 0;
  cRelatedPartyAltSubID.destroy = (void (*)(void *)) free_FIX_RelatedPartyAltSubID;
  cRelatedPartyAltSubID.trackObjects = 0;
  
  cDerivativeInstrRegistry.klass = rb_define_class_under(mQuickfix, "DerivativeInstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrRegistry, (void *) &cDerivativeInstrRegistry);
  rb_define_alloc_func(cDerivativeInstrRegistry.klass, _wrap_DerivativeInstrRegistry_allocate);
  rb_define_method(cDerivativeInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrRegistry), -1);
  cDerivativeInstrRegistry.mark = 0;
  cDerivativeInstrRegistry.destroy = (void (*)(void *)) free_FIX_DerivativeInstrRegistry;
  cDerivativeInstrRegistry.trackObjects = 0;
  
  cLegBidForwardPoints.klass = rb_define_class_under(mQuickfix, "LegBidForwardPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegBidForwardPoints, (void *) &cLegBidForwardPoints);
  rb_define_alloc_func(cLegBidForwardPoints.klass, _wrap_LegBidForwardPoints_allocate);
  rb_define_method(cLegBidForwardPoints.klass, "initialize", VALUEFUNC(_wrap_new_LegBidForwardPoints), -1);
  cLegBidForwardPoints.mark = 0;
  cLegBidForwardPoints.destroy = (void (*)(void *)) free_FIX_LegBidForwardPoints;
  cLegBidForwardPoints.trackObjects = 0;
  
  cManualOrderIndicator.klass = rb_define_class_under(mQuickfix, "ManualOrderIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ManualOrderIndicator, (void *) &cManualOrderIndicator);
  rb_define_alloc_func(cManualOrderIndicator.klass, _wrap_ManualOrderIndicator_allocate);
  rb_define_method(cManualOrderIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ManualOrderIndicator), -1);
  cManualOrderIndicator.mark = 0;
  cManualOrderIndicator.destroy = (void (*)(void *)) free_FIX_ManualOrderIndicator;
  cManualOrderIndicator.trackObjects = 0;
  
  cNetMoney.klass = rb_define_class_under(mQuickfix, "NetMoney", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetMoney, (void *) &cNetMoney);
  rb_define_alloc_func(cNetMoney.klass, _wrap_NetMoney_allocate);
  rb_define_method(cNetMoney.klass, "initialize", VALUEFUNC(_wrap_new_NetMoney), -1);
  cNetMoney.mark = 0;
  cNetMoney.destroy = (void (*)(void *)) free_FIX_NetMoney;
  cNetMoney.trackObjects = 0;
  
  cLegalConfirm.klass = rb_define_class_under(mQuickfix, "LegalConfirm", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegalConfirm, (void *) &cLegalConfirm);
  rb_define_alloc_func(cLegalConfirm.klass, _wrap_LegalConfirm_allocate);
  rb_define_method(cLegalConfirm.klass, "initialize", VALUEFUNC(_wrap_new_LegalConfirm), -1);
  cLegalConfirm.mark = 0;
  cLegalConfirm.destroy = (void (*)(void *)) free_FIX_LegalConfirm;
  cLegalConfirm.trackObjects = 0;
  
  cCountryOfIssue.klass = rb_define_class_under(mQuickfix, "CountryOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CountryOfIssue, (void *) &cCountryOfIssue);
  rb_define_alloc_func(cCountryOfIssue.klass, _wrap_CountryOfIssue_allocate);
  rb_define_method(cCountryOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_CountryOfIssue), -1);
  cCountryOfIssue.mark = 0;
  cCountryOfIssue.destroy = (void (*)(void *)) free_FIX_CountryOfIssue;
  cCountryOfIssue.trackObjects = 0;
  
  cApplReportType.klass = rb_define_class_under(mQuickfix, "ApplReportType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReportType, (void *) &cApplReportType);
  rb_define_alloc_func(cApplReportType.klass, _wrap_ApplReportType_allocate);
  rb_define_method(cApplReportType.klass, "initialize", VALUEFUNC(_wrap_new_ApplReportType), -1);
  cApplReportType.mark = 0;
  cApplReportType.destroy = (void (*)(void *)) free_FIX_ApplReportType;
  cApplReportType.trackObjects = 0;
  
  cRootPartyID.klass = rb_define_class_under(mQuickfix, "RootPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RootPartyID, (void *) &cRootPartyID);
  rb_define_alloc_func(cRootPartyID.klass, _wrap_RootPartyID_allocate);
  rb_define_method(cRootPartyID.klass, "initialize", VALUEFUNC(_wrap_new_RootPartyID), -1);
  cRootPartyID.mark = 0;
  cRootPartyID.destroy = (void (*)(void *)) free_FIX_RootPartyID;
  cRootPartyID.trackObjects = 0;
  
  cUnderlyingQty.klass = rb_define_class_under(mQuickfix, "UnderlyingQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingQty, (void *) &cUnderlyingQty);
  rb_define_alloc_func(cUnderlyingQty.klass, _wrap_UnderlyingQty_allocate);
  rb_define_method(cUnderlyingQty.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingQty), -1);
  cUnderlyingQty.mark = 0;
  cUnderlyingQty.destroy = (void (*)(void *)) free_FIX_UnderlyingQty;
  cUnderlyingQty.trackObjects = 0;
  
  cApplQueueDepth.klass = rb_define_class_under(mQuickfix, "ApplQueueDepth", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueDepth, (void *) &cApplQueueDepth);
  rb_define_alloc_func(cApplQueueDepth.klass, _wrap_ApplQueueDepth_allocate);
  rb_define_method(cApplQueueDepth.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueDepth), -1);
  cApplQueueDepth.mark = 0;
  cApplQueueDepth.destroy = (void (*)(void *)) free_FIX_ApplQueueDepth;
  cApplQueueDepth.trackObjects = 0;
  
  cStopPx.klass = rb_define_class_under(mQuickfix, "StopPx", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StopPx, (void *) &cStopPx);
  rb_define_alloc_func(cStopPx.klass, _wrap_StopPx_allocate);
  rb_define_method(cStopPx.klass, "initialize", VALUEFUNC(_wrap_new_StopPx), -1);
  cStopPx.mark = 0;
  cStopPx.destroy = (void (*)(void *)) free_FIX_StopPx;
  cStopPx.trackObjects = 0;
  
  cReportToExch.klass = rb_define_class_under(mQuickfix, "ReportToExch", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReportToExch, (void *) &cReportToExch);
  rb_define_alloc_func(cReportToExch.klass, _wrap_ReportToExch_allocate);
  rb_define_method(cReportToExch.klass, "initialize", VALUEFUNC(_wrap_new_ReportToExch), -1);
  cReportToExch.mark = 0;
  cReportToExch.destroy = (void (*)(void *)) free_FIX_ReportToExch;
  cReportToExch.trackObjects = 0;
  
  cContraryInstructionIndicator.klass = rb_define_class_under(mQuickfix, "ContraryInstructionIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContraryInstructionIndicator, (void *) &cContraryInstructionIndicator);
  rb_define_alloc_func(cContraryInstructionIndicator.klass, _wrap_ContraryInstructionIndicator_allocate);
  rb_define_method(cContraryInstructionIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ContraryInstructionIndicator), -1);
  cContraryInstructionIndicator.mark = 0;
  cContraryInstructionIndicator.destroy = (void (*)(void *)) free_FIX_ContraryInstructionIndicator;
  cContraryInstructionIndicator.trackObjects = 0;
  
  cEncodedListStatusTextLen.klass = rb_define_class_under(mQuickfix, "EncodedListStatusTextLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListStatusTextLen, (void *) &cEncodedListStatusTextLen);
  rb_define_alloc_func(cEncodedListStatusTextLen.klass, _wrap_EncodedListStatusTextLen_allocate);
  rb_define_method(cEncodedListStatusTextLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListStatusTextLen), -1);
  cEncodedListStatusTextLen.mark = 0;
  cEncodedListStatusTextLen.destroy = (void (*)(void *)) free_FIX_EncodedListStatusTextLen;
  cEncodedListStatusTextLen.trackObjects = 0;
  
  cDerivativeSecurityXMLSchema.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityXMLSchema", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema, (void *) &cDerivativeSecurityXMLSchema);
  rb_define_alloc_func(cDerivativeSecurityXMLSchema.klass, _wrap_DerivativeSecurityXMLSchema_allocate);
  rb_define_method(cDerivativeSecurityXMLSchema.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityXMLSchema), -1);
  cDerivativeSecurityXMLSchema.mark = 0;
  cDerivativeSecurityXMLSchema.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityXMLSchema;
  cDerivativeSecurityXMLSchema.trackObjects = 0;
  
  cNoRelatedSym.klass = rb_define_class_under(mQuickfix, "NoRelatedSym", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedSym, (void *) &cNoRelatedSym);
  rb_define_alloc_func(cNoRelatedSym.klass, _wrap_NoRelatedSym_allocate);
  rb_define_method(cNoRelatedSym.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedSym), -1);
  cNoRelatedSym.mark = 0;
  cNoRelatedSym.destroy = (void (*)(void *)) free_FIX_NoRelatedSym;
  cNoRelatedSym.trackObjects = 0;
  
  cAllocRejCode.klass = rb_define_class_under(mQuickfix, "AllocRejCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocRejCode, (void *) &cAllocRejCode);
  rb_define_alloc_func(cAllocRejCode.klass, _wrap_AllocRejCode_allocate);
  rb_define_method(cAllocRejCode.klass, "initialize", VALUEFUNC(_wrap_new_AllocRejCode), -1);
  cAllocRejCode.mark = 0;
  cAllocRejCode.destroy = (void (*)(void *)) free_FIX_AllocRejCode;
  cAllocRejCode.trackObjects = 0;
  
  cUnderlyingSecurityAltID.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityAltID, (void *) &cUnderlyingSecurityAltID);
  rb_define_alloc_func(cUnderlyingSecurityAltID.klass, _wrap_UnderlyingSecurityAltID_allocate);
  rb_define_method(cUnderlyingSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityAltID), -1);
  cUnderlyingSecurityAltID.mark = 0;
  cUnderlyingSecurityAltID.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityAltID;
  cUnderlyingSecurityAltID.trackObjects = 0;
  
  cNoRelationshipRiskSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoRelationshipRiskSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelationshipRiskSecurityAltID, (void *) &cNoRelationshipRiskSecurityAltID);
  rb_define_alloc_func(cNoRelationshipRiskSecurityAltID.klass, _wrap_NoRelationshipRiskSecurityAltID_allocate);
  rb_define_method(cNoRelationshipRiskSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoRelationshipRiskSecurityAltID), -1);
  cNoRelationshipRiskSecurityAltID.mark = 0;
  cNoRelationshipRiskSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoRelationshipRiskSecurityAltID;
  cNoRelationshipRiskSecurityAltID.trackObjects = 0;
  
  cRefOrdIDReason.klass = rb_define_class_under(mQuickfix, "RefOrdIDReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefOrdIDReason, (void *) &cRefOrdIDReason);
  rb_define_alloc_func(cRefOrdIDReason.klass, _wrap_RefOrdIDReason_allocate);
  rb_define_method(cRefOrdIDReason.klass, "initialize", VALUEFUNC(_wrap_new_RefOrdIDReason), -1);
  cRefOrdIDReason.mark = 0;
  cRefOrdIDReason.destroy = (void (*)(void *)) free_FIX_RefOrdIDReason;
  cRefOrdIDReason.trackObjects = 0;
  
  cDerivativeInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyID, (void *) &cDerivativeInstrumentPartyID);
  rb_define_alloc_func(cDerivativeInstrumentPartyID.klass, _wrap_DerivativeInstrumentPartyID_allocate);
  rb_define_method(cDerivativeInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartyID), -1);
  cDerivativeInstrumentPartyID.mark = 0;
  cDerivativeInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartyID;
  cDerivativeInstrumentPartyID.trackObjects = 0;
  
  cSecurityXMLSchema.klass = rb_define_class_under(mQuickfix, "SecurityXMLSchema", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityXMLSchema, (void *) &cSecurityXMLSchema);
  rb_define_alloc_func(cSecurityXMLSchema.klass, _wrap_SecurityXMLSchema_allocate);
  rb_define_method(cSecurityXMLSchema.klass, "initialize", VALUEFUNC(_wrap_new_SecurityXMLSchema), -1);
  cSecurityXMLSchema.mark = 0;
  cSecurityXMLSchema.destroy = (void (*)(void *)) free_FIX_SecurityXMLSchema;
  cSecurityXMLSchema.trackObjects = 0;
  
  cRefOrderIDSource.klass = rb_define_class_under(mQuickfix, "RefOrderIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefOrderIDSource, (void *) &cRefOrderIDSource);
  rb_define_alloc_func(cRefOrderIDSource.klass, _wrap_RefOrderIDSource_allocate);
  rb_define_method(cRefOrderIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RefOrderIDSource), -1);
  cRefOrderIDSource.mark = 0;
  cRefOrderIDSource.destroy = (void (*)(void *)) free_FIX_RefOrderIDSource;
  cRefOrderIDSource.trackObjects = 0;
  
  cNTPositionLimit.klass = rb_define_class_under(mQuickfix, "NTPositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NTPositionLimit, (void *) &cNTPositionLimit);
  rb_define_alloc_func(cNTPositionLimit.klass, _wrap_NTPositionLimit_allocate);
  rb_define_method(cNTPositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_NTPositionLimit), -1);
  cNTPositionLimit.mark = 0;
  cNTPositionLimit.destroy = (void (*)(void *)) free_FIX_NTPositionLimit;
  cNTPositionLimit.trackObjects = 0;
  
  cEndAccruedInterestAmt.klass = rb_define_class_under(mQuickfix, "EndAccruedInterestAmt", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EndAccruedInterestAmt, (void *) &cEndAccruedInterestAmt);
  rb_define_alloc_func(cEndAccruedInterestAmt.klass, _wrap_EndAccruedInterestAmt_allocate);
  rb_define_method(cEndAccruedInterestAmt.klass, "initialize", VALUEFUNC(_wrap_new_EndAccruedInterestAmt), -1);
  cEndAccruedInterestAmt.mark = 0;
  cEndAccruedInterestAmt.destroy = (void (*)(void *)) free_FIX_EndAccruedInterestAmt;
  cEndAccruedInterestAmt.trackObjects = 0;
  
  cAccruedInterestRate.klass = rb_define_class_under(mQuickfix, "AccruedInterestRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AccruedInterestRate, (void *) &cAccruedInterestRate);
  rb_define_alloc_func(cAccruedInterestRate.klass, _wrap_AccruedInterestRate_allocate);
  rb_define_method(cAccruedInterestRate.klass, "initialize", VALUEFUNC(_wrap_new_AccruedInterestRate), -1);
  cAccruedInterestRate.mark = 0;
  cAccruedInterestRate.destroy = (void (*)(void *)) free_FIX_AccruedInterestRate;
  cAccruedInterestRate.trackObjects = 0;
  
  cLastCapacity.klass = rb_define_class_under(mQuickfix, "LastCapacity", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastCapacity, (void *) &cLastCapacity);
  rb_define_alloc_func(cLastCapacity.klass, _wrap_LastCapacity_allocate);
  rb_define_method(cLastCapacity.klass, "initialize", VALUEFUNC(_wrap_new_LastCapacity), -1);
  cLastCapacity.mark = 0;
  cLastCapacity.destroy = (void (*)(void *)) free_FIX_LastCapacity;
  cLastCapacity.trackObjects = 0;
  
  cRelationshipRiskLimitCurrency.klass = rb_define_class_under(mQuickfix, "RelationshipRiskLimitCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskLimitCurrency, (void *) &cRelationshipRiskLimitCurrency);
  rb_define_alloc_func(cRelationshipRiskLimitCurrency.klass, _wrap_RelationshipRiskLimitCurrency_allocate);
  rb_define_method(cRelationshipRiskLimitCurrency.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskLimitCurrency), -1);
  cRelationshipRiskLimitCurrency.mark = 0;
  cRelationshipRiskLimitCurrency.destroy = (void (*)(void *)) free_FIX_RelationshipRiskLimitCurrency;
  cRelationshipRiskLimitCurrency.trackObjects = 0;
  
  cUnderlyingInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID, (void *) &cUnderlyingInstrumentPartySubID);
  rb_define_alloc_func(cUnderlyingInstrumentPartySubID.klass, _wrap_UnderlyingInstrumentPartySubID_allocate);
  rb_define_method(cUnderlyingInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartySubID), -1);
  cUnderlyingInstrumentPartySubID.mark = 0;
  cUnderlyingInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartySubID;
  cUnderlyingInstrumentPartySubID.trackObjects = 0;
  
  cNoFills.klass = rb_define_class_under(mQuickfix, "NoFills", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoFills, (void *) &cNoFills);
  rb_define_alloc_func(cNoFills.klass, _wrap_NoFills_allocate);
  rb_define_method(cNoFills.klass, "initialize", VALUEFUNC(_wrap_new_NoFills), -1);
  cNoFills.mark = 0;
  cNoFills.destroy = (void (*)(void *)) free_FIX_NoFills;
  cNoFills.trackObjects = 0;
  
  cNoOrdTypeRules.klass = rb_define_class_under(mQuickfix, "NoOrdTypeRules", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoOrdTypeRules, (void *) &cNoOrdTypeRules);
  rb_define_alloc_func(cNoOrdTypeRules.klass, _wrap_NoOrdTypeRules_allocate);
  rb_define_method(cNoOrdTypeRules.klass, "initialize", VALUEFUNC(_wrap_new_NoOrdTypeRules), -1);
  cNoOrdTypeRules.mark = 0;
  cNoOrdTypeRules.destroy = (void (*)(void *)) free_FIX_NoOrdTypeRules;
  cNoOrdTypeRules.trackObjects = 0;
  
  cInstrumentPartyID.klass = rb_define_class_under(mQuickfix, "InstrumentPartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrumentPartyID, (void *) &cInstrumentPartyID);
  rb_define_alloc_func(cInstrumentPartyID.klass, _wrap_InstrumentPartyID_allocate);
  rb_define_method(cInstrumentPartyID.klass, "initialize", VALUEFUNC(_wrap_new_InstrumentPartyID), -1);
  cInstrumentPartyID.mark = 0;
  cInstrumentPartyID.destroy = (void (*)(void *)) free_FIX_InstrumentPartyID;
  cInstrumentPartyID.trackObjects = 0;
  
  cMarginRatio.klass = rb_define_class_under(mQuickfix, "MarginRatio", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MarginRatio, (void *) &cMarginRatio);
  rb_define_alloc_func(cMarginRatio.klass, _wrap_MarginRatio_allocate);
  rb_define_method(cMarginRatio.klass, "initialize", VALUEFUNC(_wrap_new_MarginRatio), -1);
  cMarginRatio.mark = 0;
  cMarginRatio.destroy = (void (*)(void *)) free_FIX_MarginRatio;
  cMarginRatio.trackObjects = 0;
  
  cRefTagID.klass = rb_define_class_under(mQuickfix, "RefTagID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RefTagID, (void *) &cRefTagID);
  rb_define_alloc_func(cRefTagID.klass, _wrap_RefTagID_allocate);
  rb_define_method(cRefTagID.klass, "initialize", VALUEFUNC(_wrap_new_RefTagID), -1);
  cRefTagID.mark = 0;
  cRefTagID.destroy = (void (*)(void *)) free_FIX_RefTagID;
  cRefTagID.trackObjects = 0;
  
  cNoRoutingIDs.klass = rb_define_class_under(mQuickfix, "NoRoutingIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRoutingIDs, (void *) &cNoRoutingIDs);
  rb_define_alloc_func(cNoRoutingIDs.klass, _wrap_NoRoutingIDs_allocate);
  rb_define_method(cNoRoutingIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRoutingIDs), -1);
  cNoRoutingIDs.mark = 0;
  cNoRoutingIDs.destroy = (void (*)(void *)) free_FIX_NoRoutingIDs;
  cNoRoutingIDs.trackObjects = 0;
  
  cCouponRate.klass = rb_define_class_under(mQuickfix, "CouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CouponRate, (void *) &cCouponRate);
  rb_define_alloc_func(cCouponRate.klass, _wrap_CouponRate_allocate);
  rb_define_method(cCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_CouponRate), -1);
  cCouponRate.mark = 0;
  cCouponRate.destroy = (void (*)(void *)) free_FIX_CouponRate;
  cCouponRate.trackObjects = 0;
  
  cNoApplIDs.klass = rb_define_class_under(mQuickfix, "NoApplIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoApplIDs, (void *) &cNoApplIDs);
  rb_define_alloc_func(cNoApplIDs.klass, _wrap_NoApplIDs_allocate);
  rb_define_method(cNoApplIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoApplIDs), -1);
  cNoApplIDs.mark = 0;
  cNoApplIDs.destroy = (void (*)(void *)) free_FIX_NoApplIDs;
  cNoApplIDs.trackObjects = 0;
  
  cDerivativeContractSettlMonth.klass = rb_define_class_under(mQuickfix, "DerivativeContractSettlMonth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeContractSettlMonth, (void *) &cDerivativeContractSettlMonth);
  rb_define_alloc_func(cDerivativeContractSettlMonth.klass, _wrap_DerivativeContractSettlMonth_allocate);
  rb_define_method(cDerivativeContractSettlMonth.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeContractSettlMonth), -1);
  cDerivativeContractSettlMonth.mark = 0;
  cDerivativeContractSettlMonth.destroy = (void (*)(void *)) free_FIX_DerivativeContractSettlMonth;
  cDerivativeContractSettlMonth.trackObjects = 0;
  
  cInstrAttribType.klass = rb_define_class_under(mQuickfix, "InstrAttribType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__InstrAttribType, (void *) &cInstrAttribType);
  rb_define_alloc_func(cInstrAttribType.klass, _wrap_InstrAttribType_allocate);
  rb_define_method(cInstrAttribType.klass, "initialize", VALUEFUNC(_wrap_new_InstrAttribType), -1);
  cInstrAttribType.mark = 0;
  cInstrAttribType.destroy = (void (*)(void *)) free_FIX_InstrAttribType;
  cInstrAttribType.trackObjects = 0;
  
  cProduct.klass = rb_define_class_under(mQuickfix, "Product", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Product, (void *) &cProduct);
  rb_define_alloc_func(cProduct.klass, _wrap_Product_allocate);
  rb_define_method(cProduct.klass, "initialize", VALUEFUNC(_wrap_new_Product), -1);
  cProduct.mark = 0;
  cProduct.destroy = (void (*)(void *)) free_FIX_Product;
  cProduct.trackObjects = 0;
  
  cAllocShares.klass = rb_define_class_under(mQuickfix, "AllocShares", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocShares, (void *) &cAllocShares);
  rb_define_alloc_func(cAllocShares.klass, _wrap_AllocShares_allocate);
  rb_define_method(cAllocShares.klass, "initialize", VALUEFUNC(_wrap_new_AllocShares), -1);
  cAllocShares.mark = 0;
  cAllocShares.destroy = (void (*)(void *)) free_FIX_AllocShares;
  cAllocShares.trackObjects = 0;
  
  cNoQuoteEntries.klass = rb_define_class_under(mQuickfix, "NoQuoteEntries", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoQuoteEntries, (void *) &cNoQuoteEntries);
  rb_define_alloc_func(cNoQuoteEntries.klass, _wrap_NoQuoteEntries_allocate);
  rb_define_method(cNoQuoteEntries.klass, "initialize", VALUEFUNC(_wrap_new_NoQuoteEntries), -1);
  cNoQuoteEntries.mark = 0;
  cNoQuoteEntries.destroy = (void (*)(void *)) free_FIX_NoQuoteEntries;
  cNoQuoteEntries.trackObjects = 0;
  
  cRelationshipRiskWarningLevelName.klass = rb_define_class_under(mQuickfix, "RelationshipRiskWarningLevelName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskWarningLevelName, (void *) &cRelationshipRiskWarningLevelName);
  rb_define_alloc_func(cRelationshipRiskWarningLevelName.klass, _wrap_RelationshipRiskWarningLevelName_allocate);
  rb_define_method(cRelationshipRiskWarningLevelName.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskWarningLevelName), -1);
  cRelationshipRiskWarningLevelName.mark = 0;
  cRelationshipRiskWarningLevelName.destroy = (void (*)(void *)) free_FIX_RelationshipRiskWarningLevelName;
  cRelationshipRiskWarningLevelName.trackObjects = 0;
  
  cDefaultCstmApplVerID.klass = rb_define_class_under(mQuickfix, "DefaultCstmApplVerID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DefaultCstmApplVerID, (void *) &cDefaultCstmApplVerID);
  rb_define_alloc_func(cDefaultCstmApplVerID.klass, _wrap_DefaultCstmApplVerID_allocate);
  rb_define_method(cDefaultCstmApplVerID.klass, "initialize", VALUEFUNC(_wrap_new_DefaultCstmApplVerID), -1);
  cDefaultCstmApplVerID.mark = 0;
  cDefaultCstmApplVerID.destroy = (void (*)(void *)) free_FIX_DefaultCstmApplVerID;
  cDefaultCstmApplVerID.trackObjects = 0;
  
  cDerivativeListMethod.klass = rb_define_class_under(mQuickfix, "DerivativeListMethod", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeListMethod, (void *) &cDerivativeListMethod);
  rb_define_alloc_func(cDerivativeListMethod.klass, _wrap_DerivativeListMethod_allocate);
  rb_define_method(cDerivativeListMethod.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeListMethod), -1);
  cDerivativeListMethod.mark = 0;
  cDerivativeListMethod.destroy = (void (*)(void *)) free_FIX_DerivativeListMethod;
  cDerivativeListMethod.trackObjects = 0;
  
  cDerivativeSecurityXMLLen.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityXMLLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityXMLLen, (void *) &cDerivativeSecurityXMLLen);
  rb_define_alloc_func(cDerivativeSecurityXMLLen.klass, _wrap_DerivativeSecurityXMLLen_allocate);
  rb_define_method(cDerivativeSecurityXMLLen.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityXMLLen), -1);
  cDerivativeSecurityXMLLen.mark = 0;
  cDerivativeSecurityXMLLen.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityXMLLen;
  cDerivativeSecurityXMLLen.trackObjects = 0;
  
  cLegDatedDate.klass = rb_define_class_under(mQuickfix, "LegDatedDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegDatedDate, (void *) &cLegDatedDate);
  rb_define_alloc_func(cLegDatedDate.klass, _wrap_LegDatedDate_allocate);
  rb_define_method(cLegDatedDate.klass, "initialize", VALUEFUNC(_wrap_new_LegDatedDate), -1);
  cLegDatedDate.mark = 0;
  cLegDatedDate.destroy = (void (*)(void *)) free_FIX_LegDatedDate;
  cLegDatedDate.trackObjects = 0;
  
  cNested2PartyIDSource.klass = rb_define_class_under(mQuickfix, "Nested2PartyIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartyIDSource, (void *) &cNested2PartyIDSource);
  rb_define_alloc_func(cNested2PartyIDSource.klass, _wrap_Nested2PartyIDSource_allocate);
  rb_define_method(cNested2PartyIDSource.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartyIDSource), -1);
  cNested2PartyIDSource.mark = 0;
  cNested2PartyIDSource.destroy = (void (*)(void *)) free_FIX_Nested2PartyIDSource;
  cNested2PartyIDSource.trackObjects = 0;
  
  cUnderlyingInstrRegistry.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrRegistry", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrRegistry, (void *) &cUnderlyingInstrRegistry);
  rb_define_alloc_func(cUnderlyingInstrRegistry.klass, _wrap_UnderlyingInstrRegistry_allocate);
  rb_define_method(cUnderlyingInstrRegistry.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrRegistry), -1);
  cUnderlyingInstrRegistry.mark = 0;
  cUnderlyingInstrRegistry.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrRegistry;
  cUnderlyingInstrRegistry.trackObjects = 0;
  
  cIssueDate.klass = rb_define_class_under(mQuickfix, "IssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IssueDate, (void *) &cIssueDate);
  rb_define_alloc_func(cIssueDate.klass, _wrap_IssueDate_allocate);
  rb_define_method(cIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_IssueDate), -1);
  cIssueDate.mark = 0;
  cIssueDate.destroy = (void (*)(void *)) free_FIX_IssueDate;
  cIssueDate.trackObjects = 0;
  
  cSecurityTradingStatus.klass = rb_define_class_under(mQuickfix, "SecurityTradingStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityTradingStatus, (void *) &cSecurityTradingStatus);
  rb_define_alloc_func(cSecurityTradingStatus.klass, _wrap_SecurityTradingStatus_allocate);
  rb_define_method(cSecurityTradingStatus.klass, "initialize", VALUEFUNC(_wrap_new_SecurityTradingStatus), -1);
  cSecurityTradingStatus.mark = 0;
  cSecurityTradingStatus.destroy = (void (*)(void *)) free_FIX_SecurityTradingStatus;
  cSecurityTradingStatus.trackObjects = 0;
  
  cLegOptAttribute.klass = rb_define_class_under(mQuickfix, "LegOptAttribute", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegOptAttribute, (void *) &cLegOptAttribute);
  rb_define_alloc_func(cLegOptAttribute.klass, _wrap_LegOptAttribute_allocate);
  rb_define_method(cLegOptAttribute.klass, "initialize", VALUEFUNC(_wrap_new_LegOptAttribute), -1);
  cLegOptAttribute.mark = 0;
  cLegOptAttribute.destroy = (void (*)(void *)) free_FIX_LegOptAttribute;
  cLegOptAttribute.trackObjects = 0;
  
  cMaxFloor.klass = rb_define_class_under(mQuickfix, "MaxFloor", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaxFloor, (void *) &cMaxFloor);
  rb_define_alloc_func(cMaxFloor.klass, _wrap_MaxFloor_allocate);
  rb_define_method(cMaxFloor.klass, "initialize", VALUEFUNC(_wrap_new_MaxFloor), -1);
  cMaxFloor.mark = 0;
  cMaxFloor.destroy = (void (*)(void *)) free_FIX_MaxFloor;
  cMaxFloor.trackObjects = 0;
  
  cDerivativeLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "DerivativeLocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeLocaleOfIssue, (void *) &cDerivativeLocaleOfIssue);
  rb_define_alloc_func(cDerivativeLocaleOfIssue.klass, _wrap_DerivativeLocaleOfIssue_allocate);
  rb_define_method(cDerivativeLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeLocaleOfIssue), -1);
  cDerivativeLocaleOfIssue.mark = 0;
  cDerivativeLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_DerivativeLocaleOfIssue;
  cDerivativeLocaleOfIssue.trackObjects = 0;
  
  cOptPayAmount.klass = rb_define_class_under(mQuickfix, "OptPayAmount", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OptPayAmount, (void *) &cOptPayAmount);
  rb_define_alloc_func(cOptPayAmount.klass, _wrap_OptPayAmount_allocate);
  rb_define_method(cOptPayAmount.klass, "initialize", VALUEFUNC(_wrap_new_OptPayAmount), -1);
  cOptPayAmount.mark = 0;
  cOptPayAmount.destroy = (void (*)(void *)) free_FIX_OptPayAmount;
  cOptPayAmount.trackObjects = 0;
  
  cUnderlyingStipType.klass = rb_define_class_under(mQuickfix, "UnderlyingStipType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingStipType, (void *) &cUnderlyingStipType);
  rb_define_alloc_func(cUnderlyingStipType.klass, _wrap_UnderlyingStipType_allocate);
  rb_define_method(cUnderlyingStipType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingStipType), -1);
  cUnderlyingStipType.mark = 0;
  cUnderlyingStipType.destroy = (void (*)(void *)) free_FIX_UnderlyingStipType;
  cUnderlyingStipType.trackObjects = 0;
  
  cRule80A.klass = rb_define_class_under(mQuickfix, "Rule80A", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Rule80A, (void *) &cRule80A);
  rb_define_alloc_func(cRule80A.klass, _wrap_Rule80A_allocate);
  rb_define_method(cRule80A.klass, "initialize", VALUEFUNC(_wrap_new_Rule80A), -1);
  cRule80A.mark = 0;
  cRule80A.destroy = (void (*)(void *)) free_FIX_Rule80A;
  cRule80A.trackObjects = 0;
  
  cTotNoStrikes.klass = rb_define_class_under(mQuickfix, "TotNoStrikes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoStrikes, (void *) &cTotNoStrikes);
  rb_define_alloc_func(cTotNoStrikes.klass, _wrap_TotNoStrikes_allocate);
  rb_define_method(cTotNoStrikes.klass, "initialize", VALUEFUNC(_wrap_new_TotNoStrikes), -1);
  cTotNoStrikes.mark = 0;
  cTotNoStrikes.destroy = (void (*)(void *)) free_FIX_TotNoStrikes;
  cTotNoStrikes.trackObjects = 0;
  
  cCorporateAction.klass = rb_define_class_under(mQuickfix, "CorporateAction", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CorporateAction, (void *) &cCorporateAction);
  rb_define_alloc_func(cCorporateAction.klass, _wrap_CorporateAction_allocate);
  rb_define_method(cCorporateAction.klass, "initialize", VALUEFUNC(_wrap_new_CorporateAction), -1);
  cCorporateAction.mark = 0;
  cCorporateAction.destroy = (void (*)(void *)) free_FIX_CorporateAction;
  cCorporateAction.trackObjects = 0;
  
  cTerminationType.klass = rb_define_class_under(mQuickfix, "TerminationType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TerminationType, (void *) &cTerminationType);
  rb_define_alloc_func(cTerminationType.klass, _wrap_TerminationType_allocate);
  rb_define_method(cTerminationType.klass, "initialize", VALUEFUNC(_wrap_new_TerminationType), -1);
  cTerminationType.mark = 0;
  cTerminationType.destroy = (void (*)(void *)) free_FIX_TerminationType;
  cTerminationType.trackObjects = 0;
  
  cLegCouponRate.klass = rb_define_class_under(mQuickfix, "LegCouponRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCouponRate, (void *) &cLegCouponRate);
  rb_define_alloc_func(cLegCouponRate.klass, _wrap_LegCouponRate_allocate);
  rb_define_method(cLegCouponRate.klass, "initialize", VALUEFUNC(_wrap_new_LegCouponRate), -1);
  cLegCouponRate.mark = 0;
  cLegCouponRate.destroy = (void (*)(void *)) free_FIX_LegCouponRate;
  cLegCouponRate.trackObjects = 0;
  
  cPosMaintAction.klass = rb_define_class_under(mQuickfix, "PosMaintAction", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosMaintAction, (void *) &cPosMaintAction);
  rb_define_alloc_func(cPosMaintAction.klass, _wrap_PosMaintAction_allocate);
  rb_define_method(cPosMaintAction.klass, "initialize", VALUEFUNC(_wrap_new_PosMaintAction), -1);
  cPosMaintAction.mark = 0;
  cPosMaintAction.destroy = (void (*)(void *)) free_FIX_PosMaintAction;
  cPosMaintAction.trackObjects = 0;
  
  cNoSecurityTypes.klass = rb_define_class_under(mQuickfix, "NoSecurityTypes", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoSecurityTypes, (void *) &cNoSecurityTypes);
  rb_define_alloc_func(cNoSecurityTypes.klass, _wrap_NoSecurityTypes_allocate);
  rb_define_method(cNoSecurityTypes.klass, "initialize", VALUEFUNC(_wrap_new_NoSecurityTypes), -1);
  cNoSecurityTypes.mark = 0;
  cNoSecurityTypes.destroy = (void (*)(void *)) free_FIX_NoSecurityTypes;
  cNoSecurityTypes.trackObjects = 0;
  
  cComplexEventPriceTimeType.klass = rb_define_class_under(mQuickfix, "ComplexEventPriceTimeType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventPriceTimeType, (void *) &cComplexEventPriceTimeType);
  rb_define_alloc_func(cComplexEventPriceTimeType.klass, _wrap_ComplexEventPriceTimeType_allocate);
  rb_define_method(cComplexEventPriceTimeType.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventPriceTimeType), -1);
  cComplexEventPriceTimeType.mark = 0;
  cComplexEventPriceTimeType.destroy = (void (*)(void *)) free_FIX_ComplexEventPriceTimeType;
  cComplexEventPriceTimeType.trackObjects = 0;
  
  cLastSwapPoints.klass = rb_define_class_under(mQuickfix, "LastSwapPoints", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LastSwapPoints, (void *) &cLastSwapPoints);
  rb_define_alloc_func(cLastSwapPoints.klass, _wrap_LastSwapPoints_allocate);
  rb_define_method(cLastSwapPoints.klass, "initialize", VALUEFUNC(_wrap_new_LastSwapPoints), -1);
  cLastSwapPoints.mark = 0;
  cLastSwapPoints.destroy = (void (*)(void *)) free_FIX_LastSwapPoints;
  cLastSwapPoints.trackObjects = 0;
  
  cUnderlyingFXRateCalc.klass = rb_define_class_under(mQuickfix, "UnderlyingFXRateCalc", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingFXRateCalc, (void *) &cUnderlyingFXRateCalc);
  rb_define_alloc_func(cUnderlyingFXRateCalc.klass, _wrap_UnderlyingFXRateCalc_allocate);
  rb_define_method(cUnderlyingFXRateCalc.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingFXRateCalc), -1);
  cUnderlyingFXRateCalc.mark = 0;
  cUnderlyingFXRateCalc.destroy = (void (*)(void *)) free_FIX_UnderlyingFXRateCalc;
  cUnderlyingFXRateCalc.trackObjects = 0;
  
  cListStatusText.klass = rb_define_class_under(mQuickfix, "ListStatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListStatusText, (void *) &cListStatusText);
  rb_define_alloc_func(cListStatusText.klass, _wrap_ListStatusText_allocate);
  rb_define_method(cListStatusText.klass, "initialize", VALUEFUNC(_wrap_new_ListStatusText), -1);
  cListStatusText.mark = 0;
  cListStatusText.destroy = (void (*)(void *)) free_FIX_ListStatusText;
  cListStatusText.trackObjects = 0;
  
  cOddLot.klass = rb_define_class_under(mQuickfix, "OddLot", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OddLot, (void *) &cOddLot);
  rb_define_alloc_func(cOddLot.klass, _wrap_OddLot_allocate);
  rb_define_method(cOddLot.klass, "initialize", VALUEFUNC(_wrap_new_OddLot), -1);
  cOddLot.mark = 0;
  cOddLot.destroy = (void (*)(void *)) free_FIX_OddLot;
  cOddLot.trackObjects = 0;
  
  cBookingUnit.klass = rb_define_class_under(mQuickfix, "BookingUnit", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BookingUnit, (void *) &cBookingUnit);
  rb_define_alloc_func(cBookingUnit.klass, _wrap_BookingUnit_allocate);
  rb_define_method(cBookingUnit.klass, "initialize", VALUEFUNC(_wrap_new_BookingUnit), -1);
  cBookingUnit.mark = 0;
  cBookingUnit.destroy = (void (*)(void *)) free_FIX_BookingUnit;
  cBookingUnit.trackObjects = 0;
  
  cLegAllocAcctIDSource.klass = rb_define_class_under(mQuickfix, "LegAllocAcctIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocAcctIDSource, (void *) &cLegAllocAcctIDSource);
  rb_define_alloc_func(cLegAllocAcctIDSource.klass, _wrap_LegAllocAcctIDSource_allocate);
  rb_define_method(cLegAllocAcctIDSource.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocAcctIDSource), -1);
  cLegAllocAcctIDSource.mark = 0;
  cLegAllocAcctIDSource.destroy = (void (*)(void *)) free_FIX_LegAllocAcctIDSource;
  cLegAllocAcctIDSource.trackObjects = 0;
  
  cOnBehalfOfSendingTime.klass = rb_define_class_under(mQuickfix, "OnBehalfOfSendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OnBehalfOfSendingTime, (void *) &cOnBehalfOfSendingTime);
  rb_define_alloc_func(cOnBehalfOfSendingTime.klass, _wrap_OnBehalfOfSendingTime_allocate);
  rb_define_method(cOnBehalfOfSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_OnBehalfOfSendingTime), -1);
  cOnBehalfOfSendingTime.mark = 0;
  cOnBehalfOfSendingTime.destroy = (void (*)(void *)) free_FIX_OnBehalfOfSendingTime;
  cOnBehalfOfSendingTime.trackObjects = 0;
  
  cAllocStatus.klass = rb_define_class_under(mQuickfix, "AllocStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AllocStatus, (void *) &cAllocStatus);
  rb_define_alloc_func(cAllocStatus.klass, _wrap_AllocStatus_allocate);
  rb_define_method(cAllocStatus.klass, "initialize", VALUEFUNC(_wrap_new_AllocStatus), -1);
  cAllocStatus.mark = 0;
  cAllocStatus.destroy = (void (*)(void *)) free_FIX_AllocStatus;
  cAllocStatus.trackObjects = 0;
  
  cReferencePage.klass = rb_define_class_under(mQuickfix, "ReferencePage", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReferencePage, (void *) &cReferencePage);
  rb_define_alloc_func(cReferencePage.klass, _wrap_ReferencePage_allocate);
  rb_define_method(cReferencePage.klass, "initialize", VALUEFUNC(_wrap_new_ReferencePage), -1);
  cReferencePage.mark = 0;
  cReferencePage.destroy = (void (*)(void *)) free_FIX_ReferencePage;
  cReferencePage.trackObjects = 0;
  
  cDerivativeExerciseStyle.klass = rb_define_class_under(mQuickfix, "DerivativeExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeExerciseStyle, (void *) &cDerivativeExerciseStyle);
  rb_define_alloc_func(cDerivativeExerciseStyle.klass, _wrap_DerivativeExerciseStyle_allocate);
  rb_define_method(cDerivativeExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeExerciseStyle), -1);
  cDerivativeExerciseStyle.mark = 0;
  cDerivativeExerciseStyle.destroy = (void (*)(void *)) free_FIX_DerivativeExerciseStyle;
  cDerivativeExerciseStyle.trackObjects = 0;
  
  cApplBegSeqNum.klass = rb_define_class_under(mQuickfix, "ApplBegSeqNum", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplBegSeqNum, (void *) &cApplBegSeqNum);
  rb_define_alloc_func(cApplBegSeqNum.klass, _wrap_ApplBegSeqNum_allocate);
  rb_define_method(cApplBegSeqNum.klass, "initialize", VALUEFUNC(_wrap_new_ApplBegSeqNum), -1);
  cApplBegSeqNum.mark = 0;
  cApplBegSeqNum.destroy = (void (*)(void *)) free_FIX_ApplBegSeqNum;
  cApplBegSeqNum.trackObjects = 0;
  
  cCollRptID.klass = rb_define_class_under(mQuickfix, "CollRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CollRptID, (void *) &cCollRptID);
  rb_define_alloc_func(cCollRptID.klass, _wrap_CollRptID_allocate);
  rb_define_method(cCollRptID.klass, "initialize", VALUEFUNC(_wrap_new_CollRptID), -1);
  cCollRptID.mark = 0;
  cCollRptID.destroy = (void (*)(void *)) free_FIX_CollRptID;
  cCollRptID.trackObjects = 0;
  
  cIncTaxInd.klass = rb_define_class_under(mQuickfix, "IncTaxInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IncTaxInd, (void *) &cIncTaxInd);
  rb_define_alloc_func(cIncTaxInd.klass, _wrap_IncTaxInd_allocate);
  rb_define_method(cIncTaxInd.klass, "initialize", VALUEFUNC(_wrap_new_IncTaxInd), -1);
  cIncTaxInd.mark = 0;
  cIncTaxInd.destroy = (void (*)(void *)) free_FIX_IncTaxInd;
  cIncTaxInd.trackObjects = 0;
  
  cNoBidDescriptors.klass = rb_define_class_under(mQuickfix, "NoBidDescriptors", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoBidDescriptors, (void *) &cNoBidDescriptors);
  rb_define_alloc_func(cNoBidDescriptors.klass, _wrap_NoBidDescriptors_allocate);
  rb_define_method(cNoBidDescriptors.klass, "initialize", VALUEFUNC(_wrap_new_NoBidDescriptors), -1);
  cNoBidDescriptors.mark = 0;
  cNoBidDescriptors.destroy = (void (*)(void *)) free_FIX_NoBidDescriptors;
  cNoBidDescriptors.trackObjects = 0;
  
  cLegCouponPaymentDate.klass = rb_define_class_under(mQuickfix, "LegCouponPaymentDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegCouponPaymentDate, (void *) &cLegCouponPaymentDate);
  rb_define_alloc_func(cLegCouponPaymentDate.klass, _wrap_LegCouponPaymentDate_allocate);
  rb_define_method(cLegCouponPaymentDate.klass, "initialize", VALUEFUNC(_wrap_new_LegCouponPaymentDate), -1);
  cLegCouponPaymentDate.mark = 0;
  cLegCouponPaymentDate.destroy = (void (*)(void *)) free_FIX_LegCouponPaymentDate;
  cLegCouponPaymentDate.trackObjects = 0;
  
  cTotNoPartyList.klass = rb_define_class_under(mQuickfix, "TotNoPartyList", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TotNoPartyList, (void *) &cTotNoPartyList);
  rb_define_alloc_func(cTotNoPartyList.klass, _wrap_TotNoPartyList_allocate);
  rb_define_method(cTotNoPartyList.klass, "initialize", VALUEFUNC(_wrap_new_TotNoPartyList), -1);
  cTotNoPartyList.mark = 0;
  cTotNoPartyList.destroy = (void (*)(void *)) free_FIX_TotNoPartyList;
  cTotNoPartyList.trackObjects = 0;
  
  cPartyListResponseType.klass = rb_define_class_under(mQuickfix, "PartyListResponseType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyListResponseType, (void *) &cPartyListResponseType);
  rb_define_alloc_func(cPartyListResponseType.klass, _wrap_PartyListResponseType_allocate);
  rb_define_method(cPartyListResponseType.klass, "initialize", VALUEFUNC(_wrap_new_PartyListResponseType), -1);
  cPartyListResponseType.mark = 0;
  cPartyListResponseType.destroy = (void (*)(void *)) free_FIX_PartyListResponseType;
  cPartyListResponseType.trackObjects = 0;
  
  cNoUnderlyingLegSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoUnderlyingLegSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID, (void *) &cNoUnderlyingLegSecurityAltID);
  rb_define_alloc_func(cNoUnderlyingLegSecurityAltID.klass, _wrap_NoUnderlyingLegSecurityAltID_allocate);
  rb_define_method(cNoUnderlyingLegSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoUnderlyingLegSecurityAltID), -1);
  cNoUnderlyingLegSecurityAltID.mark = 0;
  cNoUnderlyingLegSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoUnderlyingLegSecurityAltID;
  cNoUnderlyingLegSecurityAltID.trackObjects = 0;
  
  cReversalIndicator.klass = rb_define_class_under(mQuickfix, "ReversalIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReversalIndicator, (void *) &cReversalIndicator);
  rb_define_alloc_func(cReversalIndicator.klass, _wrap_ReversalIndicator_allocate);
  rb_define_method(cReversalIndicator.klass, "initialize", VALUEFUNC(_wrap_new_ReversalIndicator), -1);
  cReversalIndicator.mark = 0;
  cReversalIndicator.destroy = (void (*)(void *)) free_FIX_ReversalIndicator;
  cReversalIndicator.trackObjects = 0;
  
  cCheckSum.klass = rb_define_class_under(mQuickfix, "CheckSum", ((swig_class *) SWIGTYPE_p_FIX__CheckSumField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CheckSum, (void *) &cCheckSum);
  rb_define_alloc_func(cCheckSum.klass, _wrap_CheckSum_allocate);
  rb_define_method(cCheckSum.klass, "initialize", VALUEFUNC(_wrap_new_CheckSum), -1);
  cCheckSum.mark = 0;
  cCheckSum.destroy = (void (*)(void *)) free_FIX_CheckSum;
  cCheckSum.trackObjects = 0;
  
  cTargetSubID.klass = rb_define_class_under(mQuickfix, "TargetSubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetSubID, (void *) &cTargetSubID);
  rb_define_alloc_func(cTargetSubID.klass, _wrap_TargetSubID_allocate);
  rb_define_method(cTargetSubID.klass, "initialize", VALUEFUNC(_wrap_new_TargetSubID), -1);
  cTargetSubID.mark = 0;
  cTargetSubID.destroy = (void (*)(void *)) free_FIX_TargetSubID;
  cTargetSubID.trackObjects = 0;
  
  cPosReqStatus.klass = rb_define_class_under(mQuickfix, "PosReqStatus", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PosReqStatus, (void *) &cPosReqStatus);
  rb_define_alloc_func(cPosReqStatus.klass, _wrap_PosReqStatus_allocate);
  rb_define_method(cPosReqStatus.klass, "initialize", VALUEFUNC(_wrap_new_PosReqStatus), -1);
  cPosReqStatus.mark = 0;
  cPosReqStatus.destroy = (void (*)(void *)) free_FIX_PosReqStatus;
  cPosReqStatus.trackObjects = 0;
  
  cPriorityIndicator.klass = rb_define_class_under(mQuickfix, "PriorityIndicator", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PriorityIndicator, (void *) &cPriorityIndicator);
  rb_define_alloc_func(cPriorityIndicator.klass, _wrap_PriorityIndicator_allocate);
  rb_define_method(cPriorityIndicator.klass, "initialize", VALUEFUNC(_wrap_new_PriorityIndicator), -1);
  cPriorityIndicator.mark = 0;
  cPriorityIndicator.destroy = (void (*)(void *)) free_FIX_PriorityIndicator;
  cPriorityIndicator.trackObjects = 0;
  
  cContextPartySubIDType.klass = rb_define_class_under(mQuickfix, "ContextPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContextPartySubIDType, (void *) &cContextPartySubIDType);
  rb_define_alloc_func(cContextPartySubIDType.klass, _wrap_ContextPartySubIDType_allocate);
  rb_define_method(cContextPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_ContextPartySubIDType), -1);
  cContextPartySubIDType.mark = 0;
  cContextPartySubIDType.destroy = (void (*)(void *)) free_FIX_ContextPartySubIDType;
  cContextPartySubIDType.trackObjects = 0;
  
  cUnderlyingLegCFICode.klass = rb_define_class_under(mQuickfix, "UnderlyingLegCFICode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegCFICode, (void *) &cUnderlyingLegCFICode);
  rb_define_alloc_func(cUnderlyingLegCFICode.klass, _wrap_UnderlyingLegCFICode_allocate);
  rb_define_method(cUnderlyingLegCFICode.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegCFICode), -1);
  cUnderlyingLegCFICode.mark = 0;
  cUnderlyingLegCFICode.destroy = (void (*)(void *)) free_FIX_UnderlyingLegCFICode;
  cUnderlyingLegCFICode.trackObjects = 0;
  
  cDerivativeTimeUnit.klass = rb_define_class_under(mQuickfix, "DerivativeTimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeTimeUnit, (void *) &cDerivativeTimeUnit);
  rb_define_alloc_func(cDerivativeTimeUnit.klass, _wrap_DerivativeTimeUnit_allocate);
  rb_define_method(cDerivativeTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeTimeUnit), -1);
  cDerivativeTimeUnit.mark = 0;
  cDerivativeTimeUnit.destroy = (void (*)(void *)) free_FIX_DerivativeTimeUnit;
  cDerivativeTimeUnit.trackObjects = 0;
  
  cNoNested3PartyIDs.klass = rb_define_class_under(mQuickfix, "NoNested3PartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoNested3PartyIDs, (void *) &cNoNested3PartyIDs);
  rb_define_alloc_func(cNoNested3PartyIDs.klass, _wrap_NoNested3PartyIDs_allocate);
  rb_define_method(cNoNested3PartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoNested3PartyIDs), -1);
  cNoNested3PartyIDs.mark = 0;
  cNoNested3PartyIDs.destroy = (void (*)(void *)) free_FIX_NoNested3PartyIDs;
  cNoNested3PartyIDs.trackObjects = 0;
  
  cLiquidityPctHigh.klass = rb_define_class_under(mQuickfix, "LiquidityPctHigh", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LiquidityPctHigh, (void *) &cLiquidityPctHigh);
  rb_define_alloc_func(cLiquidityPctHigh.klass, _wrap_LiquidityPctHigh_allocate);
  rb_define_method(cLiquidityPctHigh.klass, "initialize", VALUEFUNC(_wrap_new_LiquidityPctHigh), -1);
  cLiquidityPctHigh.mark = 0;
  cLiquidityPctHigh.destroy = (void (*)(void *)) free_FIX_LiquidityPctHigh;
  cLiquidityPctHigh.trackObjects = 0;
  
  cMoneyLaunderingStatus.klass = rb_define_class_under(mQuickfix, "MoneyLaunderingStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MoneyLaunderingStatus, (void *) &cMoneyLaunderingStatus);
  rb_define_alloc_func(cMoneyLaunderingStatus.klass, _wrap_MoneyLaunderingStatus_allocate);
  rb_define_method(cMoneyLaunderingStatus.klass, "initialize", VALUEFUNC(_wrap_new_MoneyLaunderingStatus), -1);
  cMoneyLaunderingStatus.mark = 0;
  cMoneyLaunderingStatus.destroy = (void (*)(void *)) free_FIX_MoneyLaunderingStatus;
  cMoneyLaunderingStatus.trackObjects = 0;
  
  cNested4PartySubID.klass = rb_define_class_under(mQuickfix, "Nested4PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested4PartySubID, (void *) &cNested4PartySubID);
  rb_define_alloc_func(cNested4PartySubID.klass, _wrap_Nested4PartySubID_allocate);
  rb_define_method(cNested4PartySubID.klass, "initialize", VALUEFUNC(_wrap_new_Nested4PartySubID), -1);
  cNested4PartySubID.mark = 0;
  cNested4PartySubID.destroy = (void (*)(void *)) free_FIX_Nested4PartySubID;
  cNested4PartySubID.trackObjects = 0;
  
  cDerivativeSecurityExchange.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityExchange", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityExchange, (void *) &cDerivativeSecurityExchange);
  rb_define_alloc_func(cDerivativeSecurityExchange.klass, _wrap_DerivativeSecurityExchange_allocate);
  rb_define_method(cDerivativeSecurityExchange.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityExchange), -1);
  cDerivativeSecurityExchange.mark = 0;
  cDerivativeSecurityExchange.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityExchange;
  cDerivativeSecurityExchange.trackObjects = 0;
  
  cLotType.klass = rb_define_class_under(mQuickfix, "LotType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LotType, (void *) &cLotType);
  rb_define_alloc_func(cLotType.klass, _wrap_LotType_allocate);
  rb_define_method(cLotType.klass, "initialize", VALUEFUNC(_wrap_new_LotType), -1);
  cLotType.mark = 0;
  cLotType.destroy = (void (*)(void *)) free_FIX_LotType;
  cLotType.trackObjects = 0;
  
  cContIntRptID.klass = rb_define_class_under(mQuickfix, "ContIntRptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ContIntRptID, (void *) &cContIntRptID);
  rb_define_alloc_func(cContIntRptID.klass, _wrap_ContIntRptID_allocate);
  rb_define_method(cContIntRptID.klass, "initialize", VALUEFUNC(_wrap_new_ContIntRptID), -1);
  cContIntRptID.mark = 0;
  cContIntRptID.destroy = (void (*)(void *)) free_FIX_ContIntRptID;
  cContIntRptID.trackObjects = 0;
  
  cQuoteCondition.klass = rb_define_class_under(mQuickfix, "QuoteCondition", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteCondition, (void *) &cQuoteCondition);
  rb_define_alloc_func(cQuoteCondition.klass, _wrap_QuoteCondition_allocate);
  rb_define_method(cQuoteCondition.klass, "initialize", VALUEFUNC(_wrap_new_QuoteCondition), -1);
  cQuoteCondition.mark = 0;
  cQuoteCondition.destroy = (void (*)(void *)) free_FIX_QuoteCondition;
  cQuoteCondition.trackObjects = 0;
  
  cComplexEventStartTime.klass = rb_define_class_under(mQuickfix, "ComplexEventStartTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeOnlyField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventStartTime, (void *) &cComplexEventStartTime);
  rb_define_alloc_func(cComplexEventStartTime.klass, _wrap_ComplexEventStartTime_allocate);
  rb_define_method(cComplexEventStartTime.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventStartTime), -1);
  cComplexEventStartTime.mark = 0;
  cComplexEventStartTime.destroy = (void (*)(void *)) free_FIX_ComplexEventStartTime;
  cComplexEventStartTime.trackObjects = 0;
  
  cNoComplexEvents.klass = rb_define_class_under(mQuickfix, "NoComplexEvents", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoComplexEvents, (void *) &cNoComplexEvents);
  rb_define_alloc_func(cNoComplexEvents.klass, _wrap_NoComplexEvents_allocate);
  rb_define_method(cNoComplexEvents.klass, "initialize", VALUEFUNC(_wrap_new_NoComplexEvents), -1);
  cNoComplexEvents.mark = 0;
  cNoComplexEvents.destroy = (void (*)(void *)) free_FIX_NoComplexEvents;
  cNoComplexEvents.trackObjects = 0;
  
  cDerivativeContractMultiplier.klass = rb_define_class_under(mQuickfix, "DerivativeContractMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeContractMultiplier, (void *) &cDerivativeContractMultiplier);
  rb_define_alloc_func(cDerivativeContractMultiplier.klass, _wrap_DerivativeContractMultiplier_allocate);
  rb_define_method(cDerivativeContractMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeContractMultiplier), -1);
  cDerivativeContractMultiplier.mark = 0;
  cDerivativeContractMultiplier.destroy = (void (*)(void *)) free_FIX_DerivativeContractMultiplier;
  cDerivativeContractMultiplier.trackObjects = 0;
  
  cDerivativeSecurityStatus.klass = rb_define_class_under(mQuickfix, "DerivativeSecurityStatus", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeSecurityStatus, (void *) &cDerivativeSecurityStatus);
  rb_define_alloc_func(cDerivativeSecurityStatus.klass, _wrap_DerivativeSecurityStatus_allocate);
  rb_define_method(cDerivativeSecurityStatus.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeSecurityStatus), -1);
  cDerivativeSecurityStatus.mark = 0;
  cDerivativeSecurityStatus.destroy = (void (*)(void *)) free_FIX_DerivativeSecurityStatus;
  cDerivativeSecurityStatus.trackObjects = 0;
  
  cDerivativeProductComplex.klass = rb_define_class_under(mQuickfix, "DerivativeProductComplex", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeProductComplex, (void *) &cDerivativeProductComplex);
  rb_define_alloc_func(cDerivativeProductComplex.klass, _wrap_DerivativeProductComplex_allocate);
  rb_define_method(cDerivativeProductComplex.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeProductComplex), -1);
  cDerivativeProductComplex.mark = 0;
  cDerivativeProductComplex.destroy = (void (*)(void *)) free_FIX_DerivativeProductComplex;
  cDerivativeProductComplex.trackObjects = 0;
  
  cTriggerSymbol.klass = rb_define_class_under(mQuickfix, "TriggerSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TriggerSymbol, (void *) &cTriggerSymbol);
  rb_define_alloc_func(cTriggerSymbol.klass, _wrap_TriggerSymbol_allocate);
  rb_define_method(cTriggerSymbol.klass, "initialize", VALUEFUNC(_wrap_new_TriggerSymbol), -1);
  cTriggerSymbol.mark = 0;
  cTriggerSymbol.destroy = (void (*)(void *)) free_FIX_TriggerSymbol;
  cTriggerSymbol.trackObjects = 0;
  
  cUnderlyingLocaleOfIssue.klass = rb_define_class_under(mQuickfix, "UnderlyingLocaleOfIssue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue, (void *) &cUnderlyingLocaleOfIssue);
  rb_define_alloc_func(cUnderlyingLocaleOfIssue.klass, _wrap_UnderlyingLocaleOfIssue_allocate);
  rb_define_method(cUnderlyingLocaleOfIssue.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLocaleOfIssue), -1);
  cUnderlyingLocaleOfIssue.mark = 0;
  cUnderlyingLocaleOfIssue.destroy = (void (*)(void *)) free_FIX_UnderlyingLocaleOfIssue;
  cUnderlyingLocaleOfIssue.trackObjects = 0;
  
  cSendingTime.klass = rb_define_class_under(mQuickfix, "SendingTime", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SendingTime, (void *) &cSendingTime);
  rb_define_alloc_func(cSendingTime.klass, _wrap_SendingTime_allocate);
  rb_define_method(cSendingTime.klass, "initialize", VALUEFUNC(_wrap_new_SendingTime), -1);
  cSendingTime.mark = 0;
  cSendingTime.destroy = (void (*)(void *)) free_FIX_SendingTime;
  cSendingTime.trackObjects = 0;
  
  cRelationshipRiskMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "RelationshipRiskMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskMaturityMonthYear, (void *) &cRelationshipRiskMaturityMonthYear);
  rb_define_alloc_func(cRelationshipRiskMaturityMonthYear.klass, _wrap_RelationshipRiskMaturityMonthYear_allocate);
  rb_define_method(cRelationshipRiskMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskMaturityMonthYear), -1);
  cRelationshipRiskMaturityMonthYear.mark = 0;
  cRelationshipRiskMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_RelationshipRiskMaturityMonthYear;
  cRelationshipRiskMaturityMonthYear.trackObjects = 0;
  
  cRelatedPartyAltIDSource.klass = rb_define_class_under(mQuickfix, "RelatedPartyAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedPartyAltIDSource, (void *) &cRelatedPartyAltIDSource);
  rb_define_alloc_func(cRelatedPartyAltIDSource.klass, _wrap_RelatedPartyAltIDSource_allocate);
  rb_define_method(cRelatedPartyAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_RelatedPartyAltIDSource), -1);
  cRelatedPartyAltIDSource.mark = 0;
  cRelatedPartyAltIDSource.destroy = (void (*)(void *)) free_FIX_RelatedPartyAltIDSource;
  cRelatedPartyAltIDSource.trackObjects = 0;
  
  cComplexEventStartDate.klass = rb_define_class_under(mQuickfix, "ComplexEventStartDate", ((swig_class *) SWIGTYPE_p_FIX__UtcTimeStampField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ComplexEventStartDate, (void *) &cComplexEventStartDate);
  rb_define_alloc_func(cComplexEventStartDate.klass, _wrap_ComplexEventStartDate_allocate);
  rb_define_method(cComplexEventStartDate.klass, "initialize", VALUEFUNC(_wrap_new_ComplexEventStartDate), -1);
  cComplexEventStartDate.mark = 0;
  cComplexEventStartDate.destroy = (void (*)(void *)) free_FIX_ComplexEventStartDate;
  cComplexEventStartDate.trackObjects = 0;
  
  cUnderlyingRestructuringType.klass = rb_define_class_under(mQuickfix, "UnderlyingRestructuringType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingRestructuringType, (void *) &cUnderlyingRestructuringType);
  rb_define_alloc_func(cUnderlyingRestructuringType.klass, _wrap_UnderlyingRestructuringType_allocate);
  rb_define_method(cUnderlyingRestructuringType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingRestructuringType), -1);
  cUnderlyingRestructuringType.mark = 0;
  cUnderlyingRestructuringType.destroy = (void (*)(void *)) free_FIX_UnderlyingRestructuringType;
  cUnderlyingRestructuringType.trackObjects = 0;
  
  cLegUnitOfMeasureQty.klass = rb_define_class_under(mQuickfix, "LegUnitOfMeasureQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegUnitOfMeasureQty, (void *) &cLegUnitOfMeasureQty);
  rb_define_alloc_func(cLegUnitOfMeasureQty.klass, _wrap_LegUnitOfMeasureQty_allocate);
  rb_define_method(cLegUnitOfMeasureQty.klass, "initialize", VALUEFUNC(_wrap_new_LegUnitOfMeasureQty), -1);
  cLegUnitOfMeasureQty.mark = 0;
  cLegUnitOfMeasureQty.destroy = (void (*)(void *)) free_FIX_LegUnitOfMeasureQty;
  cLegUnitOfMeasureQty.trackObjects = 0;
  
  cNoTrdRegTimestamps.klass = rb_define_class_under(mQuickfix, "NoTrdRegTimestamps", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoTrdRegTimestamps, (void *) &cNoTrdRegTimestamps);
  rb_define_alloc_func(cNoTrdRegTimestamps.klass, _wrap_NoTrdRegTimestamps_allocate);
  rb_define_method(cNoTrdRegTimestamps.klass, "initialize", VALUEFUNC(_wrap_new_NoTrdRegTimestamps), -1);
  cNoTrdRegTimestamps.mark = 0;
  cNoTrdRegTimestamps.destroy = (void (*)(void *)) free_FIX_NoTrdRegTimestamps;
  cNoTrdRegTimestamps.trackObjects = 0;
  
  cSendingDate.klass = rb_define_class_under(mQuickfix, "SendingDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SendingDate, (void *) &cSendingDate);
  rb_define_alloc_func(cSendingDate.klass, _wrap_SendingDate_allocate);
  rb_define_method(cSendingDate.klass, "initialize", VALUEFUNC(_wrap_new_SendingDate), -1);
  cSendingDate.mark = 0;
  cSendingDate.destroy = (void (*)(void *)) free_FIX_SendingDate;
  cSendingDate.trackObjects = 0;
  
  cPartyRelationship.klass = rb_define_class_under(mQuickfix, "PartyRelationship", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__PartyRelationship, (void *) &cPartyRelationship);
  rb_define_alloc_func(cPartyRelationship.klass, _wrap_PartyRelationship_allocate);
  rb_define_method(cPartyRelationship.klass, "initialize", VALUEFUNC(_wrap_new_PartyRelationship), -1);
  cPartyRelationship.mark = 0;
  cPartyRelationship.destroy = (void (*)(void *)) free_FIX_PartyRelationship;
  cPartyRelationship.trackObjects = 0;
  
  cTimeToExpiration.klass = rb_define_class_under(mQuickfix, "TimeToExpiration", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TimeToExpiration, (void *) &cTimeToExpiration);
  rb_define_alloc_func(cTimeToExpiration.klass, _wrap_TimeToExpiration_allocate);
  rb_define_method(cTimeToExpiration.klass, "initialize", VALUEFUNC(_wrap_new_TimeToExpiration), -1);
  cTimeToExpiration.mark = 0;
  cTimeToExpiration.destroy = (void (*)(void *)) free_FIX_TimeToExpiration;
  cTimeToExpiration.trackObjects = 0;
  
  cLegAllocQty.klass = rb_define_class_under(mQuickfix, "LegAllocQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegAllocQty, (void *) &cLegAllocQty);
  rb_define_alloc_func(cLegAllocQty.klass, _wrap_LegAllocQty_allocate);
  rb_define_method(cLegAllocQty.klass, "initialize", VALUEFUNC(_wrap_new_LegAllocQty), -1);
  cLegAllocQty.mark = 0;
  cLegAllocQty.destroy = (void (*)(void *)) free_FIX_LegAllocQty;
  cLegAllocQty.trackObjects = 0;
  
  cSettlLocation.klass = rb_define_class_under(mQuickfix, "SettlLocation", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlLocation, (void *) &cSettlLocation);
  rb_define_alloc_func(cSettlLocation.klass, _wrap_SettlLocation_allocate);
  rb_define_method(cSettlLocation.klass, "initialize", VALUEFUNC(_wrap_new_SettlLocation), -1);
  cSettlLocation.mark = 0;
  cSettlLocation.destroy = (void (*)(void *)) free_FIX_SettlLocation;
  cSettlLocation.trackObjects = 0;
  
  cUnderlyingExerciseStyle.klass = rb_define_class_under(mQuickfix, "UnderlyingExerciseStyle", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingExerciseStyle, (void *) &cUnderlyingExerciseStyle);
  rb_define_alloc_func(cUnderlyingExerciseStyle.klass, _wrap_UnderlyingExerciseStyle_allocate);
  rb_define_method(cUnderlyingExerciseStyle.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingExerciseStyle), -1);
  cUnderlyingExerciseStyle.mark = 0;
  cUnderlyingExerciseStyle.destroy = (void (*)(void *)) free_FIX_UnderlyingExerciseStyle;
  cUnderlyingExerciseStyle.trackObjects = 0;
  
  cCashSettlAgentContactName.klass = rb_define_class_under(mQuickfix, "CashSettlAgentContactName", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CashSettlAgentContactName, (void *) &cCashSettlAgentContactName);
  rb_define_alloc_func(cCashSettlAgentContactName.klass, _wrap_CashSettlAgentContactName_allocate);
  rb_define_method(cCashSettlAgentContactName.klass, "initialize", VALUEFUNC(_wrap_new_CashSettlAgentContactName), -1);
  cCashSettlAgentContactName.mark = 0;
  cCashSettlAgentContactName.destroy = (void (*)(void *)) free_FIX_CashSettlAgentContactName;
  cCashSettlAgentContactName.trackObjects = 0;
  
  cLegRepurchaseRate.klass = rb_define_class_under(mQuickfix, "LegRepurchaseRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegRepurchaseRate, (void *) &cLegRepurchaseRate);
  rb_define_alloc_func(cLegRepurchaseRate.klass, _wrap_LegRepurchaseRate_allocate);
  rb_define_method(cLegRepurchaseRate.klass, "initialize", VALUEFUNC(_wrap_new_LegRepurchaseRate), -1);
  cLegRepurchaseRate.mark = 0;
  cLegRepurchaseRate.destroy = (void (*)(void *)) free_FIX_LegRepurchaseRate;
  cLegRepurchaseRate.trackObjects = 0;
  
  cApplResponseID.klass = rb_define_class_under(mQuickfix, "ApplResponseID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplResponseID, (void *) &cApplResponseID);
  rb_define_alloc_func(cApplResponseID.klass, _wrap_ApplResponseID_allocate);
  rb_define_method(cApplResponseID.klass, "initialize", VALUEFUNC(_wrap_new_ApplResponseID), -1);
  cApplResponseID.mark = 0;
  cApplResponseID.destroy = (void (*)(void *)) free_FIX_ApplResponseID;
  cApplResponseID.trackObjects = 0;
  
  cNoDerivativeInstrAttrib.klass = rb_define_class_under(mQuickfix, "NoDerivativeInstrAttrib", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoDerivativeInstrAttrib, (void *) &cNoDerivativeInstrAttrib);
  rb_define_alloc_func(cNoDerivativeInstrAttrib.klass, _wrap_NoDerivativeInstrAttrib_allocate);
  rb_define_method(cNoDerivativeInstrAttrib.klass, "initialize", VALUEFUNC(_wrap_new_NoDerivativeInstrAttrib), -1);
  cNoDerivativeInstrAttrib.mark = 0;
  cNoDerivativeInstrAttrib.destroy = (void (*)(void *)) free_FIX_NoDerivativeInstrAttrib;
  cNoDerivativeInstrAttrib.trackObjects = 0;
  
  cDerivativeStrikeMultiplier.klass = rb_define_class_under(mQuickfix, "DerivativeStrikeMultiplier", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeStrikeMultiplier, (void *) &cDerivativeStrikeMultiplier);
  rb_define_alloc_func(cDerivativeStrikeMultiplier.klass, _wrap_DerivativeStrikeMultiplier_allocate);
  rb_define_method(cDerivativeStrikeMultiplier.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeStrikeMultiplier), -1);
  cDerivativeStrikeMultiplier.mark = 0;
  cDerivativeStrikeMultiplier.destroy = (void (*)(void *)) free_FIX_DerivativeStrikeMultiplier;
  cDerivativeStrikeMultiplier.trackObjects = 0;
  
  cLegStrikeCurrency.klass = rb_define_class_under(mQuickfix, "LegStrikeCurrency", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegStrikeCurrency, (void *) &cLegStrikeCurrency);
  rb_define_alloc_func(cLegStrikeCurrency.klass, _wrap_LegStrikeCurrency_allocate);
  rb_define_method(cLegStrikeCurrency.klass, "initialize", VALUEFUNC(_wrap_new_LegStrikeCurrency), -1);
  cLegStrikeCurrency.mark = 0;
  cLegStrikeCurrency.destroy = (void (*)(void *)) free_FIX_LegStrikeCurrency;
  cLegStrikeCurrency.trackObjects = 0;
  
  cSecurityStatusReqID.klass = rb_define_class_under(mQuickfix, "SecurityStatusReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecurityStatusReqID, (void *) &cSecurityStatusReqID);
  rb_define_alloc_func(cSecurityStatusReqID.klass, _wrap_SecurityStatusReqID_allocate);
  rb_define_method(cSecurityStatusReqID.klass, "initialize", VALUEFUNC(_wrap_new_SecurityStatusReqID), -1);
  cSecurityStatusReqID.mark = 0;
  cSecurityStatusReqID.destroy = (void (*)(void *)) free_FIX_SecurityStatusReqID;
  cSecurityStatusReqID.trackObjects = 0;
  
  cSecureDataLen.klass = rb_define_class_under(mQuickfix, "SecureDataLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecureDataLen, (void *) &cSecureDataLen);
  rb_define_alloc_func(cSecureDataLen.klass, _wrap_SecureDataLen_allocate);
  rb_define_method(cSecureDataLen.klass, "initialize", VALUEFUNC(_wrap_new_SecureDataLen), -1);
  cSecureDataLen.mark = 0;
  cSecureDataLen.destroy = (void (*)(void *)) free_FIX_SecureDataLen;
  cSecureDataLen.trackObjects = 0;
  
  cDiscretionScope.klass = rb_define_class_under(mQuickfix, "DiscretionScope", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionScope, (void *) &cDiscretionScope);
  rb_define_alloc_func(cDiscretionScope.klass, _wrap_DiscretionScope_allocate);
  rb_define_method(cDiscretionScope.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionScope), -1);
  cDiscretionScope.mark = 0;
  cDiscretionScope.destroy = (void (*)(void *)) free_FIX_DiscretionScope;
  cDiscretionScope.trackObjects = 0;
  
  cOwnerType.klass = rb_define_class_under(mQuickfix, "OwnerType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OwnerType, (void *) &cOwnerType);
  rb_define_alloc_func(cOwnerType.klass, _wrap_OwnerType_allocate);
  rb_define_method(cOwnerType.klass, "initialize", VALUEFUNC(_wrap_new_OwnerType), -1);
  cOwnerType.mark = 0;
  cOwnerType.destroy = (void (*)(void *)) free_FIX_OwnerType;
  cOwnerType.trackObjects = 0;
  
  cShares.klass = rb_define_class_under(mQuickfix, "Shares", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Shares, (void *) &cShares);
  rb_define_alloc_func(cShares.klass, _wrap_Shares_allocate);
  rb_define_method(cShares.klass, "initialize", VALUEFUNC(_wrap_new_Shares), -1);
  cShares.mark = 0;
  cShares.destroy = (void (*)(void *)) free_FIX_Shares;
  cShares.trackObjects = 0;
  
  cYield.klass = rb_define_class_under(mQuickfix, "Yield", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Yield, (void *) &cYield);
  rb_define_alloc_func(cYield.klass, _wrap_Yield_allocate);
  rb_define_method(cYield.klass, "initialize", VALUEFUNC(_wrap_new_Yield), -1);
  cYield.mark = 0;
  cYield.destroy = (void (*)(void *)) free_FIX_Yield;
  cYield.trackObjects = 0;
  
  cQuoteRespID.klass = rb_define_class_under(mQuickfix, "QuoteRespID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteRespID, (void *) &cQuoteRespID);
  rb_define_alloc_func(cQuoteRespID.klass, _wrap_QuoteRespID_allocate);
  rb_define_method(cQuoteRespID.klass, "initialize", VALUEFUNC(_wrap_new_QuoteRespID), -1);
  cQuoteRespID.mark = 0;
  cQuoteRespID.destroy = (void (*)(void *)) free_FIX_QuoteRespID;
  cQuoteRespID.trackObjects = 0;
  
  cRiskMaturityMonthYear.klass = rb_define_class_under(mQuickfix, "RiskMaturityMonthYear", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskMaturityMonthYear, (void *) &cRiskMaturityMonthYear);
  rb_define_alloc_func(cRiskMaturityMonthYear.klass, _wrap_RiskMaturityMonthYear_allocate);
  rb_define_method(cRiskMaturityMonthYear.klass, "initialize", VALUEFUNC(_wrap_new_RiskMaturityMonthYear), -1);
  cRiskMaturityMonthYear.mark = 0;
  cRiskMaturityMonthYear.destroy = (void (*)(void *)) free_FIX_RiskMaturityMonthYear;
  cRiskMaturityMonthYear.trackObjects = 0;
  
  cNested3PartySubID.klass = rb_define_class_under(mQuickfix, "Nested3PartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested3PartySubID, (void *) &cNested3PartySubID);
  rb_define_alloc_func(cNested3PartySubID.klass, _wrap_Nested3PartySubID_allocate);
  rb_define_method(cNested3PartySubID.klass, "initialize", VALUEFUNC(_wrap_new_Nested3PartySubID), -1);
  cNested3PartySubID.mark = 0;
  cNested3PartySubID.destroy = (void (*)(void *)) free_FIX_Nested3PartySubID;
  cNested3PartySubID.trackObjects = 0;
  
  cApplQueueResolution.klass = rb_define_class_under(mQuickfix, "ApplQueueResolution", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplQueueResolution, (void *) &cApplQueueResolution);
  rb_define_alloc_func(cApplQueueResolution.klass, _wrap_ApplQueueResolution_allocate);
  rb_define_method(cApplQueueResolution.klass, "initialize", VALUEFUNC(_wrap_new_ApplQueueResolution), -1);
  cApplQueueResolution.mark = 0;
  cApplQueueResolution.destroy = (void (*)(void *)) free_FIX_ApplQueueResolution;
  cApplQueueResolution.trackObjects = 0;
  
  cTrdRegTimestampOrigin.klass = rb_define_class_under(mQuickfix, "TrdRegTimestampOrigin", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TrdRegTimestampOrigin, (void *) &cTrdRegTimestampOrigin);
  rb_define_alloc_func(cTrdRegTimestampOrigin.klass, _wrap_TrdRegTimestampOrigin_allocate);
  rb_define_method(cTrdRegTimestampOrigin.klass, "initialize", VALUEFUNC(_wrap_new_TrdRegTimestampOrigin), -1);
  cTrdRegTimestampOrigin.mark = 0;
  cTrdRegTimestampOrigin.destroy = (void (*)(void *)) free_FIX_TrdRegTimestampOrigin;
  cTrdRegTimestampOrigin.trackObjects = 0;
  
  cNested2PartyRole.klass = rb_define_class_under(mQuickfix, "Nested2PartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartyRole, (void *) &cNested2PartyRole);
  rb_define_alloc_func(cNested2PartyRole.klass, _wrap_Nested2PartyRole_allocate);
  rb_define_method(cNested2PartyRole.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartyRole), -1);
  cNested2PartyRole.mark = 0;
  cNested2PartyRole.destroy = (void (*)(void *)) free_FIX_Nested2PartyRole;
  cNested2PartyRole.trackObjects = 0;
  
  cNested2PartyID.klass = rb_define_class_under(mQuickfix, "Nested2PartyID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Nested2PartyID, (void *) &cNested2PartyID);
  rb_define_alloc_func(cNested2PartyID.klass, _wrap_Nested2PartyID_allocate);
  rb_define_method(cNested2PartyID.klass, "initialize", VALUEFUNC(_wrap_new_Nested2PartyID), -1);
  cNested2PartyID.mark = 0;
  cNested2PartyID.destroy = (void (*)(void *)) free_FIX_Nested2PartyID;
  cNested2PartyID.trackObjects = 0;
  
  cBidSize.klass = rb_define_class_under(mQuickfix, "BidSize", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidSize, (void *) &cBidSize);
  rb_define_alloc_func(cBidSize.klass, _wrap_BidSize_allocate);
  rb_define_method(cBidSize.klass, "initialize", VALUEFUNC(_wrap_new_BidSize), -1);
  cBidSize.mark = 0;
  cBidSize.destroy = (void (*)(void *)) free_FIX_BidSize;
  cBidSize.trackObjects = 0;
  
  cLegSymbolSfx.klass = rb_define_class_under(mQuickfix, "LegSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegSymbolSfx, (void *) &cLegSymbolSfx);
  rb_define_alloc_func(cLegSymbolSfx.klass, _wrap_LegSymbolSfx_allocate);
  rb_define_method(cLegSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_LegSymbolSfx), -1);
  cLegSymbolSfx.mark = 0;
  cLegSymbolSfx.destroy = (void (*)(void *)) free_FIX_LegSymbolSfx;
  cLegSymbolSfx.trackObjects = 0;
  
  cQuoteResponseLevel.klass = rb_define_class_under(mQuickfix, "QuoteResponseLevel", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteResponseLevel, (void *) &cQuoteResponseLevel);
  rb_define_alloc_func(cQuoteResponseLevel.klass, _wrap_QuoteResponseLevel_allocate);
  rb_define_method(cQuoteResponseLevel.klass, "initialize", VALUEFUNC(_wrap_new_QuoteResponseLevel), -1);
  cQuoteResponseLevel.mark = 0;
  cQuoteResponseLevel.destroy = (void (*)(void *)) free_FIX_QuoteResponseLevel;
  cQuoteResponseLevel.trackObjects = 0;
  
  cBodyLength.klass = rb_define_class_under(mQuickfix, "BodyLength", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BodyLength, (void *) &cBodyLength);
  rb_define_alloc_func(cBodyLength.klass, _wrap_BodyLength_allocate);
  rb_define_method(cBodyLength.klass, "initialize", VALUEFUNC(_wrap_new_BodyLength), -1);
  cBodyLength.mark = 0;
  cBodyLength.destroy = (void (*)(void *)) free_FIX_BodyLength;
  cBodyLength.trackObjects = 0;
  
  cListExecInst.klass = rb_define_class_under(mQuickfix, "ListExecInst", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ListExecInst, (void *) &cListExecInst);
  rb_define_alloc_func(cListExecInst.klass, _wrap_ListExecInst_allocate);
  rb_define_method(cListExecInst.klass, "initialize", VALUEFUNC(_wrap_new_ListExecInst), -1);
  cListExecInst.mark = 0;
  cListExecInst.destroy = (void (*)(void *)) free_FIX_ListExecInst;
  cListExecInst.trackObjects = 0;
  
  cExecAckStatus.klass = rb_define_class_under(mQuickfix, "ExecAckStatus", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecAckStatus, (void *) &cExecAckStatus);
  rb_define_alloc_func(cExecAckStatus.klass, _wrap_ExecAckStatus_allocate);
  rb_define_method(cExecAckStatus.klass, "initialize", VALUEFUNC(_wrap_new_ExecAckStatus), -1);
  cExecAckStatus.mark = 0;
  cExecAckStatus.destroy = (void (*)(void *)) free_FIX_ExecAckStatus;
  cExecAckStatus.trackObjects = 0;
  
  cSettlDate2.klass = rb_define_class_under(mQuickfix, "SettlDate2", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlDate2, (void *) &cSettlDate2);
  rb_define_alloc_func(cSettlDate2.klass, _wrap_SettlDate2_allocate);
  rb_define_method(cSettlDate2.klass, "initialize", VALUEFUNC(_wrap_new_SettlDate2), -1);
  cSettlDate2.mark = 0;
  cSettlDate2.destroy = (void (*)(void *)) free_FIX_SettlDate2;
  cSettlDate2.trackObjects = 0;
  
  cNetGrossInd.klass = rb_define_class_under(mQuickfix, "NetGrossInd", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetGrossInd, (void *) &cNetGrossInd);
  rb_define_alloc_func(cNetGrossInd.klass, _wrap_NetGrossInd_allocate);
  rb_define_method(cNetGrossInd.klass, "initialize", VALUEFUNC(_wrap_new_NetGrossInd), -1);
  cNetGrossInd.mark = 0;
  cNetGrossInd.destroy = (void (*)(void *)) free_FIX_NetGrossInd;
  cNetGrossInd.trackObjects = 0;
  
  cUnderlyingSecurityAltIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingSecurityAltIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource, (void *) &cUnderlyingSecurityAltIDSource);
  rb_define_alloc_func(cUnderlyingSecurityAltIDSource.klass, _wrap_UnderlyingSecurityAltIDSource_allocate);
  rb_define_method(cUnderlyingSecurityAltIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingSecurityAltIDSource), -1);
  cUnderlyingSecurityAltIDSource.mark = 0;
  cUnderlyingSecurityAltIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingSecurityAltIDSource;
  cUnderlyingSecurityAltIDSource.trackObjects = 0;
  
  cTestReqID.klass = rb_define_class_under(mQuickfix, "TestReqID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TestReqID, (void *) &cTestReqID);
  rb_define_alloc_func(cTestReqID.klass, _wrap_TestReqID_allocate);
  rb_define_method(cTestReqID.klass, "initialize", VALUEFUNC(_wrap_new_TestReqID), -1);
  cTestReqID.mark = 0;
  cTestReqID.destroy = (void (*)(void *)) free_FIX_TestReqID;
  cTestReqID.trackObjects = 0;
  
  cCxlType.klass = rb_define_class_under(mQuickfix, "CxlType", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CxlType, (void *) &cCxlType);
  rb_define_alloc_func(cCxlType.klass, _wrap_CxlType_allocate);
  rb_define_method(cCxlType.klass, "initialize", VALUEFUNC(_wrap_new_CxlType), -1);
  cCxlType.mark = 0;
  cCxlType.destroy = (void (*)(void *)) free_FIX_CxlType;
  cCxlType.trackObjects = 0;
  
  cUnderlyingCreditRating.klass = rb_define_class_under(mQuickfix, "UnderlyingCreditRating", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCreditRating, (void *) &cUnderlyingCreditRating);
  rb_define_alloc_func(cUnderlyingCreditRating.klass, _wrap_UnderlyingCreditRating_allocate);
  rb_define_method(cUnderlyingCreditRating.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCreditRating), -1);
  cUnderlyingCreditRating.mark = 0;
  cUnderlyingCreditRating.destroy = (void (*)(void *)) free_FIX_UnderlyingCreditRating;
  cUnderlyingCreditRating.trackObjects = 0;
  
  cAvgPxPrecision.klass = rb_define_class_under(mQuickfix, "AvgPxPrecision", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AvgPxPrecision, (void *) &cAvgPxPrecision);
  rb_define_alloc_func(cAvgPxPrecision.klass, _wrap_AvgPxPrecision_allocate);
  rb_define_method(cAvgPxPrecision.klass, "initialize", VALUEFUNC(_wrap_new_AvgPxPrecision), -1);
  cAvgPxPrecision.mark = 0;
  cAvgPxPrecision.destroy = (void (*)(void *)) free_FIX_AvgPxPrecision;
  cAvgPxPrecision.trackObjects = 0;
  
  cBenchmarkPriceType.klass = rb_define_class_under(mQuickfix, "BenchmarkPriceType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BenchmarkPriceType, (void *) &cBenchmarkPriceType);
  rb_define_alloc_func(cBenchmarkPriceType.klass, _wrap_BenchmarkPriceType_allocate);
  rb_define_method(cBenchmarkPriceType.klass, "initialize", VALUEFUNC(_wrap_new_BenchmarkPriceType), -1);
  cBenchmarkPriceType.mark = 0;
  cBenchmarkPriceType.destroy = (void (*)(void *)) free_FIX_BenchmarkPriceType;
  cBenchmarkPriceType.trackObjects = 0;
  
  cDeskTypeSource.klass = rb_define_class_under(mQuickfix, "DeskTypeSource", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DeskTypeSource, (void *) &cDeskTypeSource);
  rb_define_alloc_func(cDeskTypeSource.klass, _wrap_DeskTypeSource_allocate);
  rb_define_method(cDeskTypeSource.klass, "initialize", VALUEFUNC(_wrap_new_DeskTypeSource), -1);
  cDeskTypeSource.mark = 0;
  cDeskTypeSource.destroy = (void (*)(void *)) free_FIX_DeskTypeSource;
  cDeskTypeSource.trackObjects = 0;
  
  cDiscretionRoundDirection.klass = rb_define_class_under(mQuickfix, "DiscretionRoundDirection", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionRoundDirection, (void *) &cDiscretionRoundDirection);
  rb_define_alloc_func(cDiscretionRoundDirection.klass, _wrap_DiscretionRoundDirection_allocate);
  rb_define_method(cDiscretionRoundDirection.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionRoundDirection), -1);
  cDiscretionRoundDirection.mark = 0;
  cDiscretionRoundDirection.destroy = (void (*)(void *)) free_FIX_DiscretionRoundDirection;
  cDiscretionRoundDirection.trackObjects = 0;
  
  cOrigSecondaryTradeID.klass = rb_define_class_under(mQuickfix, "OrigSecondaryTradeID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrigSecondaryTradeID, (void *) &cOrigSecondaryTradeID);
  rb_define_alloc_func(cOrigSecondaryTradeID.klass, _wrap_OrigSecondaryTradeID_allocate);
  rb_define_method(cOrigSecondaryTradeID.klass, "initialize", VALUEFUNC(_wrap_new_OrigSecondaryTradeID), -1);
  cOrigSecondaryTradeID.mark = 0;
  cOrigSecondaryTradeID.destroy = (void (*)(void *)) free_FIX_OrigSecondaryTradeID;
  cOrigSecondaryTradeID.trackObjects = 0;
  
  cReceivedDeptID.klass = rb_define_class_under(mQuickfix, "ReceivedDeptID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ReceivedDeptID, (void *) &cReceivedDeptID);
  rb_define_alloc_func(cReceivedDeptID.klass, _wrap_ReceivedDeptID_allocate);
  rb_define_method(cReceivedDeptID.klass, "initialize", VALUEFUNC(_wrap_new_ReceivedDeptID), -1);
  cReceivedDeptID.mark = 0;
  cReceivedDeptID.destroy = (void (*)(void *)) free_FIX_ReceivedDeptID;
  cReceivedDeptID.trackObjects = 0;
  
  cMaturityNetMoney.klass = rb_define_class_under(mQuickfix, "MaturityNetMoney", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MaturityNetMoney, (void *) &cMaturityNetMoney);
  rb_define_alloc_func(cMaturityNetMoney.klass, _wrap_MaturityNetMoney_allocate);
  rb_define_method(cMaturityNetMoney.klass, "initialize", VALUEFUNC(_wrap_new_MaturityNetMoney), -1);
  cMaturityNetMoney.mark = 0;
  cMaturityNetMoney.destroy = (void (*)(void *)) free_FIX_MaturityNetMoney;
  cMaturityNetMoney.trackObjects = 0;
  
  cBidDescriptorType.klass = rb_define_class_under(mQuickfix, "BidDescriptorType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BidDescriptorType, (void *) &cBidDescriptorType);
  rb_define_alloc_func(cBidDescriptorType.klass, _wrap_BidDescriptorType_allocate);
  rb_define_method(cBidDescriptorType.klass, "initialize", VALUEFUNC(_wrap_new_BidDescriptorType), -1);
  cBidDescriptorType.mark = 0;
  cBidDescriptorType.destroy = (void (*)(void *)) free_FIX_BidDescriptorType;
  cBidDescriptorType.trackObjects = 0;
  
  cRiskEncodedSecurityDescLen.klass = rb_define_class_under(mQuickfix, "RiskEncodedSecurityDescLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskEncodedSecurityDescLen, (void *) &cRiskEncodedSecurityDescLen);
  rb_define_alloc_func(cRiskEncodedSecurityDescLen.klass, _wrap_RiskEncodedSecurityDescLen_allocate);
  rb_define_method(cRiskEncodedSecurityDescLen.klass, "initialize", VALUEFUNC(_wrap_new_RiskEncodedSecurityDescLen), -1);
  cRiskEncodedSecurityDescLen.mark = 0;
  cRiskEncodedSecurityDescLen.destroy = (void (*)(void *)) free_FIX_RiskEncodedSecurityDescLen;
  cRiskEncodedSecurityDescLen.trackObjects = 0;
  
  cRelationshipRiskSymbol.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSymbol", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSymbol, (void *) &cRelationshipRiskSymbol);
  rb_define_alloc_func(cRelationshipRiskSymbol.klass, _wrap_RelationshipRiskSymbol_allocate);
  rb_define_method(cRelationshipRiskSymbol.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSymbol), -1);
  cRelationshipRiskSymbol.mark = 0;
  cRelationshipRiskSymbol.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSymbol;
  cRelationshipRiskSymbol.trackObjects = 0;
  
  cNoRelatedContextPartyIDs.klass = rb_define_class_under(mQuickfix, "NoRelatedContextPartyIDs", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRelatedContextPartyIDs, (void *) &cNoRelatedContextPartyIDs);
  rb_define_alloc_func(cNoRelatedContextPartyIDs.klass, _wrap_NoRelatedContextPartyIDs_allocate);
  rb_define_method(cNoRelatedContextPartyIDs.klass, "initialize", VALUEFUNC(_wrap_new_NoRelatedContextPartyIDs), -1);
  cNoRelatedContextPartyIDs.mark = 0;
  cNoRelatedContextPartyIDs.destroy = (void (*)(void *)) free_FIX_NoRelatedContextPartyIDs;
  cNoRelatedContextPartyIDs.trackObjects = 0;
  
  cDerivativeInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "DerivativeInstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID, (void *) &cDerivativeInstrumentPartySubID);
  rb_define_alloc_func(cDerivativeInstrumentPartySubID.klass, _wrap_DerivativeInstrumentPartySubID_allocate);
  rb_define_method(cDerivativeInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_DerivativeInstrumentPartySubID), -1);
  cDerivativeInstrumentPartySubID.mark = 0;
  cDerivativeInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_DerivativeInstrumentPartySubID;
  cDerivativeInstrumentPartySubID.trackObjects = 0;
  
  cNetworkStatusResponseType.klass = rb_define_class_under(mQuickfix, "NetworkStatusResponseType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NetworkStatusResponseType, (void *) &cNetworkStatusResponseType);
  rb_define_alloc_func(cNetworkStatusResponseType.klass, _wrap_NetworkStatusResponseType_allocate);
  rb_define_method(cNetworkStatusResponseType.klass, "initialize", VALUEFUNC(_wrap_new_NetworkStatusResponseType), -1);
  cNetworkStatusResponseType.mark = 0;
  cNetworkStatusResponseType.destroy = (void (*)(void *)) free_FIX_NetworkStatusResponseType;
  cNetworkStatusResponseType.trackObjects = 0;
  
  cDateOfBirth.klass = rb_define_class_under(mQuickfix, "DateOfBirth", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DateOfBirth, (void *) &cDateOfBirth);
  rb_define_alloc_func(cDateOfBirth.klass, _wrap_DateOfBirth_allocate);
  rb_define_method(cDateOfBirth.klass, "initialize", VALUEFUNC(_wrap_new_DateOfBirth), -1);
  cDateOfBirth.mark = 0;
  cDateOfBirth.destroy = (void (*)(void *)) free_FIX_DateOfBirth;
  cDateOfBirth.trackObjects = 0;
  
  cRelatedContextPartySubIDType.klass = rb_define_class_under(mQuickfix, "RelatedContextPartySubIDType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelatedContextPartySubIDType, (void *) &cRelatedContextPartySubIDType);
  rb_define_alloc_func(cRelatedContextPartySubIDType.klass, _wrap_RelatedContextPartySubIDType_allocate);
  rb_define_method(cRelatedContextPartySubIDType.klass, "initialize", VALUEFUNC(_wrap_new_RelatedContextPartySubIDType), -1);
  cRelatedContextPartySubIDType.mark = 0;
  cRelatedContextPartySubIDType.destroy = (void (*)(void *)) free_FIX_RelatedContextPartySubIDType;
  cRelatedContextPartySubIDType.trackObjects = 0;
  
  cStartStrikePxRange.klass = rb_define_class_under(mQuickfix, "StartStrikePxRange", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StartStrikePxRange, (void *) &cStartStrikePxRange);
  rb_define_alloc_func(cStartStrikePxRange.klass, _wrap_StartStrikePxRange_allocate);
  rb_define_method(cStartStrikePxRange.klass, "initialize", VALUEFUNC(_wrap_new_StartStrikePxRange), -1);
  cStartStrikePxRange.mark = 0;
  cStartStrikePxRange.destroy = (void (*)(void *)) free_FIX_StartStrikePxRange;
  cStartStrikePxRange.trackObjects = 0;
  
  cUndlyInstrumentPartySubID.klass = rb_define_class_under(mQuickfix, "UndlyInstrumentPartySubID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartySubID, (void *) &cUndlyInstrumentPartySubID);
  rb_define_alloc_func(cUndlyInstrumentPartySubID.klass, _wrap_UndlyInstrumentPartySubID_allocate);
  rb_define_method(cUndlyInstrumentPartySubID.klass, "initialize", VALUEFUNC(_wrap_new_UndlyInstrumentPartySubID), -1);
  cUndlyInstrumentPartySubID.mark = 0;
  cUndlyInstrumentPartySubID.destroy = (void (*)(void *)) free_FIX_UndlyInstrumentPartySubID;
  cUndlyInstrumentPartySubID.trackObjects = 0;
  
  cSecondaryTradeReportRefID.klass = rb_define_class_under(mQuickfix, "SecondaryTradeReportRefID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SecondaryTradeReportRefID, (void *) &cSecondaryTradeReportRefID);
  rb_define_alloc_func(cSecondaryTradeReportRefID.klass, _wrap_SecondaryTradeReportRefID_allocate);
  rb_define_method(cSecondaryTradeReportRefID.klass, "initialize", VALUEFUNC(_wrap_new_SecondaryTradeReportRefID), -1);
  cSecondaryTradeReportRefID.mark = 0;
  cSecondaryTradeReportRefID.destroy = (void (*)(void *)) free_FIX_SecondaryTradeReportRefID;
  cSecondaryTradeReportRefID.trackObjects = 0;
  
  cUnderlyingCPRegType.klass = rb_define_class_under(mQuickfix, "UnderlyingCPRegType", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingCPRegType, (void *) &cUnderlyingCPRegType);
  rb_define_alloc_func(cUnderlyingCPRegType.klass, _wrap_UnderlyingCPRegType_allocate);
  rb_define_method(cUnderlyingCPRegType.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingCPRegType), -1);
  cUnderlyingCPRegType.mark = 0;
  cUnderlyingCPRegType.destroy = (void (*)(void *)) free_FIX_UnderlyingCPRegType;
  cUnderlyingCPRegType.trackObjects = 0;
  
  cSignatureLength.klass = rb_define_class_under(mQuickfix, "SignatureLength", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SignatureLength, (void *) &cSignatureLength);
  rb_define_alloc_func(cSignatureLength.klass, _wrap_SignatureLength_allocate);
  rb_define_method(cSignatureLength.klass, "initialize", VALUEFUNC(_wrap_new_SignatureLength), -1);
  cSignatureLength.mark = 0;
  cSignatureLength.destroy = (void (*)(void *)) free_FIX_SignatureLength;
  cSignatureLength.trackObjects = 0;
  
  cOrderQty.klass = rb_define_class_under(mQuickfix, "OrderQty", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OrderQty, (void *) &cOrderQty);
  rb_define_alloc_func(cOrderQty.klass, _wrap_OrderQty_allocate);
  rb_define_method(cOrderQty.klass, "initialize", VALUEFUNC(_wrap_new_OrderQty), -1);
  cOrderQty.mark = 0;
  cOrderQty.destroy = (void (*)(void *)) free_FIX_OrderQty;
  cOrderQty.trackObjects = 0;
  
  cRelationshipRiskWarningLevelPercent.klass = rb_define_class_under(mQuickfix, "RelationshipRiskWarningLevelPercent", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskWarningLevelPercent, (void *) &cRelationshipRiskWarningLevelPercent);
  rb_define_alloc_func(cRelationshipRiskWarningLevelPercent.klass, _wrap_RelationshipRiskWarningLevelPercent_allocate);
  rb_define_method(cRelationshipRiskWarningLevelPercent.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskWarningLevelPercent), -1);
  cRelationshipRiskWarningLevelPercent.mark = 0;
  cRelationshipRiskWarningLevelPercent.destroy = (void (*)(void *)) free_FIX_RelationshipRiskWarningLevelPercent;
  cRelationshipRiskWarningLevelPercent.trackObjects = 0;
  
  cOriginalNotionalPercentageOutstanding.klass = rb_define_class_under(mQuickfix, "OriginalNotionalPercentageOutstanding", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding, (void *) &cOriginalNotionalPercentageOutstanding);
  rb_define_alloc_func(cOriginalNotionalPercentageOutstanding.klass, _wrap_OriginalNotionalPercentageOutstanding_allocate);
  rb_define_method(cOriginalNotionalPercentageOutstanding.klass, "initialize", VALUEFUNC(_wrap_new_OriginalNotionalPercentageOutstanding), -1);
  cOriginalNotionalPercentageOutstanding.mark = 0;
  cOriginalNotionalPercentageOutstanding.destroy = (void (*)(void *)) free_FIX_OriginalNotionalPercentageOutstanding;
  cOriginalNotionalPercentageOutstanding.trackObjects = 0;
  
  cUnderlyingTimeUnit.klass = rb_define_class_under(mQuickfix, "UnderlyingTimeUnit", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingTimeUnit, (void *) &cUnderlyingTimeUnit);
  rb_define_alloc_func(cUnderlyingTimeUnit.klass, _wrap_UnderlyingTimeUnit_allocate);
  rb_define_method(cUnderlyingTimeUnit.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingTimeUnit), -1);
  cUnderlyingTimeUnit.mark = 0;
  cUnderlyingTimeUnit.destroy = (void (*)(void *)) free_FIX_UnderlyingTimeUnit;
  cUnderlyingTimeUnit.trackObjects = 0;
  
  cEncodedHeadlineLen.klass = rb_define_class_under(mQuickfix, "EncodedHeadlineLen", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedHeadlineLen, (void *) &cEncodedHeadlineLen);
  rb_define_alloc_func(cEncodedHeadlineLen.klass, _wrap_EncodedHeadlineLen_allocate);
  rb_define_method(cEncodedHeadlineLen.klass, "initialize", VALUEFUNC(_wrap_new_EncodedHeadlineLen), -1);
  cEncodedHeadlineLen.mark = 0;
  cEncodedHeadlineLen.destroy = (void (*)(void *)) free_FIX_EncodedHeadlineLen;
  cEncodedHeadlineLen.trackObjects = 0;
  
  cNoRegistDtls.klass = rb_define_class_under(mQuickfix, "NoRegistDtls", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRegistDtls, (void *) &cNoRegistDtls);
  rb_define_alloc_func(cNoRegistDtls.klass, _wrap_NoRegistDtls_allocate);
  rb_define_method(cNoRegistDtls.klass, "initialize", VALUEFUNC(_wrap_new_NoRegistDtls), -1);
  cNoRegistDtls.mark = 0;
  cNoRegistDtls.destroy = (void (*)(void *)) free_FIX_NoRegistDtls;
  cNoRegistDtls.trackObjects = 0;
  
  cStrategyParameterValue.klass = rb_define_class_under(mQuickfix, "StrategyParameterValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StrategyParameterValue, (void *) &cStrategyParameterValue);
  rb_define_alloc_func(cStrategyParameterValue.klass, _wrap_StrategyParameterValue_allocate);
  rb_define_method(cStrategyParameterValue.klass, "initialize", VALUEFUNC(_wrap_new_StrategyParameterValue), -1);
  cStrategyParameterValue.mark = 0;
  cStrategyParameterValue.destroy = (void (*)(void *)) free_FIX_StrategyParameterValue;
  cStrategyParameterValue.trackObjects = 0;
  
  cRiskSecurityDesc.klass = rb_define_class_under(mQuickfix, "RiskSecurityDesc", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityDesc, (void *) &cRiskSecurityDesc);
  rb_define_alloc_func(cRiskSecurityDesc.klass, _wrap_RiskSecurityDesc_allocate);
  rb_define_method(cRiskSecurityDesc.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityDesc), -1);
  cRiskSecurityDesc.mark = 0;
  cRiskSecurityDesc.destroy = (void (*)(void *)) free_FIX_RiskSecurityDesc;
  cRiskSecurityDesc.trackObjects = 0;
  
  cNoInstrumentParties.klass = rb_define_class_under(mQuickfix, "NoInstrumentParties", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoInstrumentParties, (void *) &cNoInstrumentParties);
  rb_define_alloc_func(cNoInstrumentParties.klass, _wrap_NoInstrumentParties_allocate);
  rb_define_method(cNoInstrumentParties.klass, "initialize", VALUEFUNC(_wrap_new_NoInstrumentParties), -1);
  cNoInstrumentParties.mark = 0;
  cNoInstrumentParties.destroy = (void (*)(void *)) free_FIX_NoInstrumentParties;
  cNoInstrumentParties.trackObjects = 0;
  
  cQuoteType.klass = rb_define_class_under(mQuickfix, "QuoteType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__QuoteType, (void *) &cQuoteType);
  rb_define_alloc_func(cQuoteType.klass, _wrap_QuoteType_allocate);
  rb_define_method(cQuoteType.klass, "initialize", VALUEFUNC(_wrap_new_QuoteType), -1);
  cQuoteType.mark = 0;
  cQuoteType.destroy = (void (*)(void *)) free_FIX_QuoteType;
  cQuoteType.trackObjects = 0;
  
  cNoRiskSecurityAltID.klass = rb_define_class_under(mQuickfix, "NoRiskSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoRiskSecurityAltID, (void *) &cNoRiskSecurityAltID);
  rb_define_alloc_func(cNoRiskSecurityAltID.klass, _wrap_NoRiskSecurityAltID_allocate);
  rb_define_method(cNoRiskSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_NoRiskSecurityAltID), -1);
  cNoRiskSecurityAltID.mark = 0;
  cNoRiskSecurityAltID.destroy = (void (*)(void *)) free_FIX_NoRiskSecurityAltID;
  cNoRiskSecurityAltID.trackObjects = 0;
  
  cNoStrategyParameters.klass = rb_define_class_under(mQuickfix, "NoStrategyParameters", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NoStrategyParameters, (void *) &cNoStrategyParameters);
  rb_define_alloc_func(cNoStrategyParameters.klass, _wrap_NoStrategyParameters_allocate);
  rb_define_method(cNoStrategyParameters.klass, "initialize", VALUEFUNC(_wrap_new_NoStrategyParameters), -1);
  cNoStrategyParameters.mark = 0;
  cNoStrategyParameters.destroy = (void (*)(void *)) free_FIX_NoStrategyParameters;
  cNoStrategyParameters.trackObjects = 0;
  
  cIndividualAllocRejCode.klass = rb_define_class_under(mQuickfix, "IndividualAllocRejCode", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IndividualAllocRejCode, (void *) &cIndividualAllocRejCode);
  rb_define_alloc_func(cIndividualAllocRejCode.klass, _wrap_IndividualAllocRejCode_allocate);
  rb_define_method(cIndividualAllocRejCode.klass, "initialize", VALUEFUNC(_wrap_new_IndividualAllocRejCode), -1);
  cIndividualAllocRejCode.mark = 0;
  cIndividualAllocRejCode.destroy = (void (*)(void *)) free_FIX_IndividualAllocRejCode;
  cIndividualAllocRejCode.trackObjects = 0;
  
  cDiscretionInst.klass = rb_define_class_under(mQuickfix, "DiscretionInst", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DiscretionInst, (void *) &cDiscretionInst);
  rb_define_alloc_func(cDiscretionInst.klass, _wrap_DiscretionInst_allocate);
  rb_define_method(cDiscretionInst.klass, "initialize", VALUEFUNC(_wrap_new_DiscretionInst), -1);
  cDiscretionInst.mark = 0;
  cDiscretionInst.destroy = (void (*)(void *)) free_FIX_DiscretionInst;
  cDiscretionInst.trackObjects = 0;
  
  cRiskSecurityAltID.klass = rb_define_class_under(mQuickfix, "RiskSecurityAltID", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RiskSecurityAltID, (void *) &cRiskSecurityAltID);
  rb_define_alloc_func(cRiskSecurityAltID.klass, _wrap_RiskSecurityAltID_allocate);
  rb_define_method(cRiskSecurityAltID.klass, "initialize", VALUEFUNC(_wrap_new_RiskSecurityAltID), -1);
  cRiskSecurityAltID.mark = 0;
  cRiskSecurityAltID.destroy = (void (*)(void *)) free_FIX_RiskSecurityAltID;
  cRiskSecurityAltID.trackObjects = 0;
  
  cTargetPartyRole.klass = rb_define_class_under(mQuickfix, "TargetPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TargetPartyRole, (void *) &cTargetPartyRole);
  rb_define_alloc_func(cTargetPartyRole.klass, _wrap_TargetPartyRole_allocate);
  rb_define_method(cTargetPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_TargetPartyRole), -1);
  cTargetPartyRole.mark = 0;
  cTargetPartyRole.destroy = (void (*)(void *)) free_FIX_TargetPartyRole;
  cTargetPartyRole.trackObjects = 0;
  
  cCrossPrioritization.klass = rb_define_class_under(mQuickfix, "CrossPrioritization", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__CrossPrioritization, (void *) &cCrossPrioritization);
  rb_define_alloc_func(cCrossPrioritization.klass, _wrap_CrossPrioritization_allocate);
  rb_define_method(cCrossPrioritization.klass, "initialize", VALUEFUNC(_wrap_new_CrossPrioritization), -1);
  cCrossPrioritization.mark = 0;
  cCrossPrioritization.destroy = (void (*)(void *)) free_FIX_CrossPrioritization;
  cCrossPrioritization.trackObjects = 0;
  
  cEncodedListStatusText.klass = rb_define_class_under(mQuickfix, "EncodedListStatusText", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__EncodedListStatusText, (void *) &cEncodedListStatusText);
  rb_define_alloc_func(cEncodedListStatusText.klass, _wrap_EncodedListStatusText_allocate);
  rb_define_method(cEncodedListStatusText.klass, "initialize", VALUEFUNC(_wrap_new_EncodedListStatusText), -1);
  cEncodedListStatusText.mark = 0;
  cEncodedListStatusText.destroy = (void (*)(void *)) free_FIX_EncodedListStatusText;
  cEncodedListStatusText.trackObjects = 0;
  
  cIOIOthSvc.klass = rb_define_class_under(mQuickfix, "IOIOthSvc", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__IOIOthSvc, (void *) &cIOIOthSvc);
  rb_define_alloc_func(cIOIOthSvc.klass, _wrap_IOIOthSvc_allocate);
  rb_define_method(cIOIOthSvc.klass, "initialize", VALUEFUNC(_wrap_new_IOIOthSvc), -1);
  cIOIOthSvc.mark = 0;
  cIOIOthSvc.destroy = (void (*)(void *)) free_FIX_IOIOthSvc;
  cIOIOthSvc.trackObjects = 0;
  
  cLegIssueDate.klass = rb_define_class_under(mQuickfix, "LegIssueDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LegIssueDate, (void *) &cLegIssueDate);
  rb_define_alloc_func(cLegIssueDate.klass, _wrap_LegIssueDate_allocate);
  rb_define_method(cLegIssueDate.klass, "initialize", VALUEFUNC(_wrap_new_LegIssueDate), -1);
  cLegIssueDate.mark = 0;
  cLegIssueDate.destroy = (void (*)(void *)) free_FIX_LegIssueDate;
  cLegIssueDate.trackObjects = 0;
  
  cMDReqRejReason.klass = rb_define_class_under(mQuickfix, "MDReqRejReason", ((swig_class *) SWIGTYPE_p_FIX__CharField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MDReqRejReason, (void *) &cMDReqRejReason);
  rb_define_alloc_func(cMDReqRejReason.klass, _wrap_MDReqRejReason_allocate);
  rb_define_method(cMDReqRejReason.klass, "initialize", VALUEFUNC(_wrap_new_MDReqRejReason), -1);
  cMDReqRejReason.mark = 0;
  cMDReqRejReason.destroy = (void (*)(void *)) free_FIX_MDReqRejReason;
  cMDReqRejReason.trackObjects = 0;
  
  cRelationshipRiskPutOrCall.klass = rb_define_class_under(mQuickfix, "RelationshipRiskPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskPutOrCall, (void *) &cRelationshipRiskPutOrCall);
  rb_define_alloc_func(cRelationshipRiskPutOrCall.klass, _wrap_RelationshipRiskPutOrCall_allocate);
  rb_define_method(cRelationshipRiskPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskPutOrCall), -1);
  cRelationshipRiskPutOrCall.mark = 0;
  cRelationshipRiskPutOrCall.destroy = (void (*)(void *)) free_FIX_RelationshipRiskPutOrCall;
  cRelationshipRiskPutOrCall.trackObjects = 0;
  
  cApplReqType.klass = rb_define_class_under(mQuickfix, "ApplReqType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ApplReqType, (void *) &cApplReqType);
  rb_define_alloc_func(cApplReqType.klass, _wrap_ApplReqType_allocate);
  rb_define_method(cApplReqType.klass, "initialize", VALUEFUNC(_wrap_new_ApplReqType), -1);
  cApplReqType.mark = 0;
  cApplReqType.destroy = (void (*)(void *)) free_FIX_ApplReqType;
  cApplReqType.trackObjects = 0;
  
  cCountry.klass = rb_define_class_under(mQuickfix, "Country", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Country, (void *) &cCountry);
  rb_define_alloc_func(cCountry.klass, _wrap_Country_allocate);
  rb_define_method(cCountry.klass, "initialize", VALUEFUNC(_wrap_new_Country), -1);
  cCountry.mark = 0;
  cCountry.destroy = (void (*)(void *)) free_FIX_Country;
  cCountry.trackObjects = 0;
  
  cUnderlyingLegSecurityIDSource.klass = rb_define_class_under(mQuickfix, "UnderlyingLegSecurityIDSource", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource, (void *) &cUnderlyingLegSecurityIDSource);
  rb_define_alloc_func(cUnderlyingLegSecurityIDSource.klass, _wrap_UnderlyingLegSecurityIDSource_allocate);
  rb_define_method(cUnderlyingLegSecurityIDSource.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingLegSecurityIDSource), -1);
  cUnderlyingLegSecurityIDSource.mark = 0;
  cUnderlyingLegSecurityIDSource.destroy = (void (*)(void *)) free_FIX_UnderlyingLegSecurityIDSource;
  cUnderlyingLegSecurityIDSource.trackObjects = 0;
  
  cFlexProductEligibilityIndicator.klass = rb_define_class_under(mQuickfix, "FlexProductEligibilityIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FlexProductEligibilityIndicator, (void *) &cFlexProductEligibilityIndicator);
  rb_define_alloc_func(cFlexProductEligibilityIndicator.klass, _wrap_FlexProductEligibilityIndicator_allocate);
  rb_define_method(cFlexProductEligibilityIndicator.klass, "initialize", VALUEFUNC(_wrap_new_FlexProductEligibilityIndicator), -1);
  cFlexProductEligibilityIndicator.mark = 0;
  cFlexProductEligibilityIndicator.destroy = (void (*)(void *)) free_FIX_FlexProductEligibilityIndicator;
  cFlexProductEligibilityIndicator.trackObjects = 0;
  
  cAggressorIndicator.klass = rb_define_class_under(mQuickfix, "AggressorIndicator", ((swig_class *) SWIGTYPE_p_FIX__BoolField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__AggressorIndicator, (void *) &cAggressorIndicator);
  rb_define_alloc_func(cAggressorIndicator.klass, _wrap_AggressorIndicator_allocate);
  rb_define_method(cAggressorIndicator.klass, "initialize", VALUEFUNC(_wrap_new_AggressorIndicator), -1);
  cAggressorIndicator.mark = 0;
  cAggressorIndicator.destroy = (void (*)(void *)) free_FIX_AggressorIndicator;
  cAggressorIndicator.trackObjects = 0;
  
  cExecPriceAdjustment.klass = rb_define_class_under(mQuickfix, "ExecPriceAdjustment", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ExecPriceAdjustment, (void *) &cExecPriceAdjustment);
  rb_define_alloc_func(cExecPriceAdjustment.klass, _wrap_ExecPriceAdjustment_allocate);
  rb_define_method(cExecPriceAdjustment.klass, "initialize", VALUEFUNC(_wrap_new_ExecPriceAdjustment), -1);
  cExecPriceAdjustment.mark = 0;
  cExecPriceAdjustment.destroy = (void (*)(void *)) free_FIX_ExecPriceAdjustment;
  cExecPriceAdjustment.trackObjects = 0;
  
  cBusinessRejectReason.klass = rb_define_class_under(mQuickfix, "BusinessRejectReason", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BusinessRejectReason, (void *) &cBusinessRejectReason);
  rb_define_alloc_func(cBusinessRejectReason.klass, _wrap_BusinessRejectReason_allocate);
  rb_define_method(cBusinessRejectReason.klass, "initialize", VALUEFUNC(_wrap_new_BusinessRejectReason), -1);
  cBusinessRejectReason.mark = 0;
  cBusinessRejectReason.destroy = (void (*)(void *)) free_FIX_BusinessRejectReason;
  cBusinessRejectReason.trackObjects = 0;
  
  cTradeDate.klass = rb_define_class_under(mQuickfix, "TradeDate", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TradeDate, (void *) &cTradeDate);
  rb_define_alloc_func(cTradeDate.klass, _wrap_TradeDate_allocate);
  rb_define_method(cTradeDate.klass, "initialize", VALUEFUNC(_wrap_new_TradeDate), -1);
  cTradeDate.mark = 0;
  cTradeDate.destroy = (void (*)(void *)) free_FIX_TradeDate;
  cTradeDate.trackObjects = 0;
  
  cUnderlyingPutOrCall.klass = rb_define_class_under(mQuickfix, "UnderlyingPutOrCall", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingPutOrCall, (void *) &cUnderlyingPutOrCall);
  rb_define_alloc_func(cUnderlyingPutOrCall.klass, _wrap_UnderlyingPutOrCall_allocate);
  rb_define_method(cUnderlyingPutOrCall.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingPutOrCall), -1);
  cUnderlyingPutOrCall.mark = 0;
  cUnderlyingPutOrCall.destroy = (void (*)(void *)) free_FIX_UnderlyingPutOrCall;
  cUnderlyingPutOrCall.trackObjects = 0;
  
  cRelationshipRiskSymbolSfx.klass = rb_define_class_under(mQuickfix, "RelationshipRiskSymbolSfx", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__RelationshipRiskSymbolSfx, (void *) &cRelationshipRiskSymbolSfx);
  rb_define_alloc_func(cRelationshipRiskSymbolSfx.klass, _wrap_RelationshipRiskSymbolSfx_allocate);
  rb_define_method(cRelationshipRiskSymbolSfx.klass, "initialize", VALUEFUNC(_wrap_new_RelationshipRiskSymbolSfx), -1);
  cRelationshipRiskSymbolSfx.mark = 0;
  cRelationshipRiskSymbolSfx.destroy = (void (*)(void *)) free_FIX_RelationshipRiskSymbolSfx;
  cRelationshipRiskSymbolSfx.trackObjects = 0;
  
  cUnderlyingInstrumentPartyRole.klass = rb_define_class_under(mQuickfix, "UnderlyingInstrumentPartyRole", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole, (void *) &cUnderlyingInstrumentPartyRole);
  rb_define_alloc_func(cUnderlyingInstrumentPartyRole.klass, _wrap_UnderlyingInstrumentPartyRole_allocate);
  rb_define_method(cUnderlyingInstrumentPartyRole.klass, "initialize", VALUEFUNC(_wrap_new_UnderlyingInstrumentPartyRole), -1);
  cUnderlyingInstrumentPartyRole.mark = 0;
  cUnderlyingInstrumentPartyRole.destroy = (void (*)(void *)) free_FIX_UnderlyingInstrumentPartyRole;
  cUnderlyingInstrumentPartyRole.trackObjects = 0;
  
  cDerivativePositionLimit.klass = rb_define_class_under(mQuickfix, "DerivativePositionLimit", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DerivativePositionLimit, (void *) &cDerivativePositionLimit);
  rb_define_alloc_func(cDerivativePositionLimit.klass, _wrap_DerivativePositionLimit_allocate);
  rb_define_method(cDerivativePositionLimit.klass, "initialize", VALUEFUNC(_wrap_new_DerivativePositionLimit), -1);
  cDerivativePositionLimit.mark = 0;
  cDerivativePositionLimit.destroy = (void (*)(void *)) free_FIX_DerivativePositionLimit;
  cDerivativePositionLimit.trackObjects = 0;
  
  cTierCode.klass = rb_define_class_under(mQuickfix, "TierCode", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__TierCode, (void *) &cTierCode);
  rb_define_alloc_func(cTierCode.klass, _wrap_TierCode_allocate);
  rb_define_method(cTierCode.klass, "initialize", VALUEFUNC(_wrap_new_TierCode), -1);
  cTierCode.mark = 0;
  cTierCode.destroy = (void (*)(void *)) free_FIX_TierCode;
  cTierCode.trackObjects = 0;
  
  cBookingType.klass = rb_define_class_under(mQuickfix, "BookingType", ((swig_class *) SWIGTYPE_p_FIX__IntField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__BookingType, (void *) &cBookingType);
  rb_define_alloc_func(cBookingType.klass, _wrap_BookingType_allocate);
  rb_define_method(cBookingType.klass, "initialize", VALUEFUNC(_wrap_new_BookingType), -1);
  cBookingType.mark = 0;
  cBookingType.destroy = (void (*)(void *)) free_FIX_BookingType;
  cBookingType.trackObjects = 0;
  
  cStipulationValue.klass = rb_define_class_under(mQuickfix, "StipulationValue", ((swig_class *) SWIGTYPE_p_FIX__StringField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__StipulationValue, (void *) &cStipulationValue);
  rb_define_alloc_func(cStipulationValue.klass, _wrap_StipulationValue_allocate);
  rb_define_method(cStipulationValue.klass, "initialize", VALUEFUNC(_wrap_new_StipulationValue), -1);
  cStipulationValue.mark = 0;
  cStipulationValue.destroy = (void (*)(void *)) free_FIX_StipulationValue;
  cStipulationValue.trackObjects = 0;
  
  cSettlCurrBidFxRate.klass = rb_define_class_under(mQuickfix, "SettlCurrBidFxRate", ((swig_class *) SWIGTYPE_p_FIX__DoubleField->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SettlCurrBidFxRate, (void *) &cSettlCurrBidFxRate);
  rb_define_alloc_func(cSettlCurrBidFxRate.klass, _wrap_SettlCurrBidFxRate_allocate);
  rb_define_method(cSettlCurrBidFxRate.klass, "initialize", VALUEFUNC(_wrap_new_SettlCurrBidFxRate), -1);
  cSettlCurrBidFxRate.mark = 0;
  cSettlCurrBidFxRate.destroy = (void (*)(void *)) free_FIX_SettlCurrBidFxRate;
  cSettlCurrBidFxRate.trackObjects = 0;
  rb_define_singleton_method(mQuickfix, "BeginString_FIXT11", VALUEFUNC(BeginString_FIXT11_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX50", VALUEFUNC(BeginString_FIX50_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX44", VALUEFUNC(BeginString_FIX44_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX43", VALUEFUNC(BeginString_FIX43_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX42", VALUEFUNC(BeginString_FIX42_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX41", VALUEFUNC(BeginString_FIX41_get), 0);
  rb_define_singleton_method(mQuickfix, "BeginString_FIX40", VALUEFUNC(BeginString_FIX40_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_TAG_NUMBER_TEXT", VALUEFUNC(SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REQUIRED_TAG_MISSING_TEXT", VALUEFUNC(SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT", VALUEFUNC(SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_UNDEFINED_TAG_TEXT", VALUEFUNC(SessionRejectReason_UNDEFINED_TAG_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT", VALUEFUNC(SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_VALUE_IS_INCORRECT_TEXT", VALUEFUNC(SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT", VALUEFUNC(SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_DECRYPTION_PROBLEM_TEXT", VALUEFUNC(SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SIGNATURE_PROBLEM_TEXT", VALUEFUNC(SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_COMPID_PROBLEM_TEXT", VALUEFUNC(SessionRejectReason_COMPID_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT", VALUEFUNC(SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_MSGTYPE_TEXT", VALUEFUNC(SessionRejectReason_INVALID_MSGTYPE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT", VALUEFUNC(SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT", VALUEFUNC(SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT", VALUEFUNC(SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_OTHER_TEXT", VALUEFUNC(BusinessRejectReason_OTHER_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_ID_TEXT", VALUEFUNC(BusinessRejectReason_UNKNOWN_ID_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_SECURITY_TEXT", VALUEFUNC(BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT", VALUEFUNC(BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT", VALUEFUNC(BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT", VALUEFUNC(BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_NOT_AUTHORIZED_TEXT", VALUEFUNC(BusinessRejectReason_NOT_AUTHORIZED_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT", VALUEFUNC(BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryForm_BOOKENTRY", VALUEFUNC(DeliveryForm_BOOKENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryForm_BEARER", VALUEFUNC(DeliveryForm_BEARER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryForm_BOOK_ENTRY", VALUEFUNC(DeliveryForm_BOOK_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_GTRENEW", VALUEFUNC(ExecRestatementReason_GTRENEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_WAREHOUSE_RECAP", VALUEFUNC(ExecRestatementReason_WAREHOUSE_RECAP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CANCELEDNOTBEST", VALUEFUNC(ExecRestatementReason_CANCELEDNOTBEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE", VALUEFUNC(ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CXLTRADINGHALT", VALUEFUNC(ExecRestatementReason_CXLTRADINGHALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY", VALUEFUNC(ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_GT_CORPORATE_ACTION", VALUEFUNC(ExecRestatementReason_GT_CORPORATE_ACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_PEG_REFRESH", VALUEFUNC(ExecRestatementReason_PEG_REFRESH_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_VERBAL", VALUEFUNC(ExecRestatementReason_VERBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CANCELED_NOT_BEST", VALUEFUNC(ExecRestatementReason_CANCELED_NOT_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CANCEL_ON_TRADING_HALT", VALUEFUNC(ExecRestatementReason_CANCEL_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_REPX", VALUEFUNC(ExecRestatementReason_REPX_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_MRKTOPTION", VALUEFUNC(ExecRestatementReason_MRKTOPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_VERBAL_CHANGE", VALUEFUNC(ExecRestatementReason_VERBAL_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_PARTDEC", VALUEFUNC(ExecRestatementReason_PARTDEC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_CXLSYSTEMFAILURE", VALUEFUNC(ExecRestatementReason_CXLSYSTEMFAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_GTCORPACT", VALUEFUNC(ExecRestatementReason_GTCORPACT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_OTHER", VALUEFUNC(ExecRestatementReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_BROKER_OPTION", VALUEFUNC(ExecRestatementReason_BROKER_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_WAREHOUSERECAP", VALUEFUNC(ExecRestatementReason_WAREHOUSERECAP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_BRKROPT", VALUEFUNC(ExecRestatementReason_BRKROPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_REPRICING_OF_ORDER", VALUEFUNC(ExecRestatementReason_REPRICING_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_MARKET", VALUEFUNC(ExecRestatementReason_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecRestatementReason_GT_RENEWAL", VALUEFUNC(ExecRestatementReason_GT_RENEWAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDING_RELEASE", VALUEFUNC(AllocIntermedReqType_PENDING_RELEASE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDING_REVERSAL", VALUEFUNC(AllocIntermedReqType_PENDING_REVERSAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_ACCOUNTLEVELREJECT", VALUEFUNC(AllocIntermedReqType_ACCOUNTLEVELREJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDINGACCEPT", VALUEFUNC(AllocIntermedReqType_PENDINGACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_BLOCK_LEVEL_REJECT", VALUEFUNC(AllocIntermedReqType_BLOCK_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_ACCOUNT_LEVEL_REJECT", VALUEFUNC(AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_BLOCKLEVELREJECT", VALUEFUNC(AllocIntermedReqType_BLOCKLEVELREJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDING_ACCEPT", VALUEFUNC(AllocIntermedReqType_PENDING_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDINGREVERSAL", VALUEFUNC(AllocIntermedReqType_PENDINGREVERSAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_PENDINGRELEASE", VALUEFUNC(AllocIntermedReqType_PENDINGRELEASE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocIntermedReqType_ACCEPT", VALUEFUNC(AllocIntermedReqType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListTypeSource_GICS", VALUEFUNC(SecurityListTypeSource_GICS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListTypeSource_NAICS", VALUEFUNC(SecurityListTypeSource_NAICS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListTypeSource_ICB", VALUEFUNC(SecurityListTypeSource_ICB_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_PARTIALLY_ASSIGNED", VALUEFUNC(CollInquiryQualifier_PARTIALLY_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_OUTSTANDING_TRADES", VALUEFUNC(CollInquiryQualifier_OUTSTANDING_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_SUBSTITUTIONELIGIBLE", VALUEFUNC(CollInquiryQualifier_SUBSTITUTIONELIGIBLE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_TRADE_DATE", VALUEFUNC(CollInquiryQualifier_TRADE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_FULLYASSIGNED", VALUEFUNC(CollInquiryQualifier_FULLYASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_SUBSTITUTION_ELIGIBLE", VALUEFUNC(CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_FULLY_ASSIGNED", VALUEFUNC(CollInquiryQualifier_FULLY_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_NOTASSIGNED", VALUEFUNC(CollInquiryQualifier_NOTASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_GCINSTRUMENT", VALUEFUNC(CollInquiryQualifier_GCINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_NOT_ASSIGNED", VALUEFUNC(CollInquiryQualifier_NOT_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_COLLATERAL_INSTRUMENT", VALUEFUNC(CollInquiryQualifier_COLLATERAL_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_OUTSTANDINGTRADES", VALUEFUNC(CollInquiryQualifier_OUTSTANDINGTRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_TRADEDATE", VALUEFUNC(CollInquiryQualifier_TRADEDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_GC_INSTRUMENT", VALUEFUNC(CollInquiryQualifier_GC_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_PARTIALLYASSIGNED", VALUEFUNC(CollInquiryQualifier_PARTIALLYASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryQualifier_COLLATERALINSTRUMENT", VALUEFUNC(CollInquiryQualifier_COLLATERALINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_UPDATES_THE_OTHER_4", VALUEFUNC(ContingencyType_ONE_UPDATES_THE_OTHER_4_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_TRIGGERS_THE_OTHER", VALUEFUNC(ContingencyType_ONE_TRIGGERS_THE_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_CANCELS_THE_OTHER", VALUEFUNC(ContingencyType_ONE_CANCELS_THE_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ContingencyType_ONE_UPDATES_THE_OTHER_3", VALUEFUNC(ContingencyType_ONE_UPDATES_THE_OTHER_3_get), 0);
  rb_define_singleton_method(mQuickfix, "EmailType_NEW", VALUEFUNC(EmailType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "EmailType_REPLY", VALUEFUNC(EmailType_REPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "EmailType_ADMIN_REPLY", VALUEFUNC(EmailType_ADMIN_REPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "EmailType_ADMINREPLY", VALUEFUNC(EmailType_ADMINREPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQltyInd_MEDIUM", VALUEFUNC(IOIQltyInd_MEDIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQltyInd_HIGH", VALUEFUNC(IOIQltyInd_HIGH_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQltyInd_LOW", VALUEFUNC(IOIQltyInd_LOW_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY", VALUEFUNC(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(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(MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNTCUSTOMER", VALUEFUNC(AccountType_ACCOUNTCUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_HOUSE_TRADER", VALUEFUNC(AccountType_HOUSE_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS", VALUEFUNC(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(AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_FLOOR_TRADER", VALUEFUNC(AccountType_FLOOR_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_JOINT_BACK_OFFICE_ACCOUNT", VALUEFUNC(AccountType_JOINT_BACK_OFFICE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_HOUSETRADER", VALUEFUNC(AccountType_HOUSETRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_FLOORTRADER", VALUEFUNC(AccountType_FLOORTRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNTNONCUSTOMERCROSS", VALUEFUNC(AccountType_ACCOUNTNONCUSTOMERCROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED", VALUEFUNC(AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNTNONCUSTOMER", VALUEFUNC(AccountType_ACCOUNTNONCUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_HOUSETRADERCROSS", VALUEFUNC(AccountType_HOUSETRADERCROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_JOINTBOACCT", VALUEFUNC(AccountType_JOINTBOACCT_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_JOINT_BACKOFFICE_ACCOUNT", VALUEFUNC(AccountType_JOINT_BACKOFFICE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED", VALUEFUNC(AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_ADDITIONAL_INFORMATION", VALUEFUNC(HaltReasonInt_ADDITIONAL_INFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_NEWS_PENDING", VALUEFUNC(HaltReasonInt_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_ORDER_INFLUX", VALUEFUNC(HaltReasonInt_ORDER_INFLUX_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_NEWS_DISSEMINATION", VALUEFUNC(HaltReasonInt_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_EQUIPMENT_CHANGEOVER", VALUEFUNC(HaltReasonInt_EQUIPMENT_CHANGEOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonInt_ORDER_IMBALANCE", VALUEFUNC(HaltReasonInt_ORDER_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_3RDYEARDELEGATE", VALUEFUNC(ClearingFeeIndicator_3RDYEARDELEGATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_FULLASSOCIATEMEMBER", VALUEFUNC(ClearingFeeIndicator_FULLASSOCIATEMEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_106H_AND_106J_FIRMS", VALUEFUNC(ClearingFeeIndicator_106H_AND_106J_FIRMS_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_4THYEARDELEGATE", VALUEFUNC(ClearingFeeIndicator_4THYEARDELEGATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_5THYEARDELEGATE", VALUEFUNC(ClearingFeeIndicator_5THYEARDELEGATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_EQUITYCLEARINGMEMBER", VALUEFUNC(ClearingFeeIndicator_EQUITYCLEARINGMEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP", VALUEFUNC(ClearingFeeIndicator_GIMIDEMCOMMEMBERSHIP_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_2NDYEARDELEGATE", VALUEFUNC(ClearingFeeIndicator_2NDYEARDELEGATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_1STYEARDELEGATE", VALUEFUNC(ClearingFeeIndicator_1STYEARDELEGATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_106H106J", VALUEFUNC(ClearingFeeIndicator_106H106J_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS", VALUEFUNC(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(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(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(ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_LESSEE_106F_EMPLOYEES", VALUEFUNC(ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_6THYEARDELEGATE", VALUEFUNC(ClearingFeeIndicator_6THYEARDELEGATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER", VALUEFUNC(ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(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(ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_CBOE_MEMBER", VALUEFUNC(ClearingFeeIndicator_CBOE_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_NONMEMBERCUSTOMER", VALUEFUNC(ClearingFeeIndicator_NONMEMBERCUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES", VALUEFUNC(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(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(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(ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_CBOEMEMBER", VALUEFUNC(ClearingFeeIndicator_CBOEMEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_LESSEE106F", VALUEFUNC(ClearingFeeIndicator_LESSEE106F_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_ALLOTHERS", VALUEFUNC(ClearingFeeIndicator_ALLOTHERS_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER", VALUEFUNC(ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES", VALUEFUNC(ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT", VALUEFUNC(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(ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT", VALUEFUNC(ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_DISCLOSED_STYLE", VALUEFUNC(BidType_DISCLOSED_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_NONDISC", VALUEFUNC(BidType_NONDISC_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_NO_BIDDING_PROCESS", VALUEFUNC(BidType_NO_BIDDING_PROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_DISC", VALUEFUNC(BidType_DISC_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_DISCLOSED_SYTLE", VALUEFUNC(BidType_DISCLOSED_SYTLE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_NOBID", VALUEFUNC(BidType_NOBID_get), 0);
  rb_define_singleton_method(mQuickfix, "BidType_NON_DISCLOSED_STYLE", VALUEFUNC(BidType_NON_DISCLOSED_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PER_SHARE", VALUEFUNC(QuotePriceType_PER_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK", VALUEFUNC(QuotePriceType_BASISPOINTSRELATIVETOBENCHMARK_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_TEDPRICE", VALUEFUNC(QuotePriceType_TEDPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PERSHARE", VALUEFUNC(QuotePriceType_PERSHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_YIELD", VALUEFUNC(QuotePriceType_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_FIXED_AMOUNT", VALUEFUNC(QuotePriceType_FIXED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_TED_YIELD", VALUEFUNC(QuotePriceType_TED_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PREMIUM", VALUEFUNC(QuotePriceType_PREMIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_FIXEDAMOUNT", VALUEFUNC(QuotePriceType_FIXEDAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_YIELDSPREADSWAPS", VALUEFUNC(QuotePriceType_YIELDSPREADSWAPS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_TEDYIELD", VALUEFUNC(QuotePriceType_TEDYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_DISCOUNT", VALUEFUNC(QuotePriceType_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_YIELD_SPREAD", VALUEFUNC(QuotePriceType_YIELD_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_TED_PRICE", VALUEFUNC(QuotePriceType_TED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_PERCENT", VALUEFUNC(QuotePriceType_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuotePriceType_SPREAD", VALUEFUNC(QuotePriceType_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE", VALUEFUNC(MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_REVERSED_NET_PRICE", VALUEFUNC(MultilegPriceMethod_REVERSED_NET_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_MULTIPLIED_PRICE", VALUEFUNC(MultilegPriceMethod_MULTIPLIED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_INDIVIDUAL", VALUEFUNC(MultilegPriceMethod_INDIVIDUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_YIELD_DIFFERENCE", VALUEFUNC(MultilegPriceMethod_YIELD_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegPriceMethod_NET_PRICE", VALUEFUNC(MultilegPriceMethod_NET_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListMethod_PRE_LISTED_ONLY", VALUEFUNC(ListMethod_PRE_LISTED_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ListMethod_USER_REQUESTED", VALUEFUNC(ListMethod_USER_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MDImplicitDelete_NO", VALUEFUNC(MDImplicitDelete_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "MDImplicitDelete_YES", VALUEFUNC(MDImplicitDelete_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_BLOCKLIST", VALUEFUNC(RoutingType_BLOCKLIST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_TARGET_LIST", VALUEFUNC(RoutingType_TARGET_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_TARGET_FIRM", VALUEFUNC(RoutingType_TARGET_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_TARGETFIRM", VALUEFUNC(RoutingType_TARGETFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_TARGETLIST", VALUEFUNC(RoutingType_TARGETLIST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_BLOCK_LIST", VALUEFUNC(RoutingType_BLOCK_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_BLOCK_FIRM", VALUEFUNC(RoutingType_BLOCK_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "RoutingType_BLOCKFIRM", VALUEFUNC(RoutingType_BLOCKFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_RISKTRADE", VALUEFUNC(BidTradeType_RISKTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_VWAPGUARANTEE", VALUEFUNC(BidTradeType_VWAPGUARANTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_AGENCY", VALUEFUNC(BidTradeType_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_GUARANTEEDCLOSE", VALUEFUNC(BidTradeType_GUARANTEEDCLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_VWAP_GUARANTEE", VALUEFUNC(BidTradeType_VWAP_GUARANTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_RISK_TRADE", VALUEFUNC(BidTradeType_RISK_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidTradeType_GUARANTEED_CLOSE", VALUEFUNC(BidTradeType_GUARANTEED_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INCORRECT_ALLOCATED_QUANTITY", VALUEFUNC(OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER", VALUEFUNC(OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_DUPLICATEVERBAL", VALUEFUNC(OrdRejReason_DUPLICATEVERBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_ORDER_EXCEEDS_LIMIT", VALUEFUNC(OrdRejReason_ORDER_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_EXCHANGE_CLOSED", VALUEFUNC(OrdRejReason_EXCHANGE_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_DUPLICATE", VALUEFUNC(OrdRejReason_DUPLICATE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_SURVEILLENCE_OPTION", VALUEFUNC(OrdRejReason_SURVEILLENCE_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWN_ORDER", VALUEFUNC(OrdRejReason_UNKNOWN_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INCORRECTALLOCATEDQUANTITY", VALUEFUNC(OrdRejReason_INCORRECTALLOCATEDQUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_TOOLATE", VALUEFUNC(OrdRejReason_TOOLATE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC", VALUEFUNC(OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_DUPLICATE_ORDER", VALUEFUNC(OrdRejReason_DUPLICATE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_TOO_LATE_TO_ENTER", VALUEFUNC(OrdRejReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INCORRECT_QUANTITY", VALUEFUNC(OrdRejReason_INCORRECT_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWNSYM", VALUEFUNC(OrdRejReason_UNKNOWNSYM_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_STALE", VALUEFUNC(OrdRejReason_STALE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWN_ACCOUNT", VALUEFUNC(OrdRejReason_UNKNOWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INVALID_PRICE_INCREMENT", VALUEFUNC(OrdRejReason_INVALID_PRICE_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_BROKEROPT", VALUEFUNC(OrdRejReason_BROKEROPT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_EXCEEDSLIM", VALUEFUNC(OrdRejReason_EXCEEDSLIM_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INVALID_INVESTOR_ID", VALUEFUNC(OrdRejReason_INVALID_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWN_SYMBOL", VALUEFUNC(OrdRejReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INCORRECTQUANTITY", VALUEFUNC(OrdRejReason_INCORRECTQUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWNACCOUNTS", VALUEFUNC(OrdRejReason_UNKNOWNACCOUNTS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_OTHER", VALUEFUNC(OrdRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_BROKER", VALUEFUNC(OrdRejReason_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_BROKER_OPTION", VALUEFUNC(OrdRejReason_BROKER_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_SURVEILLENCE", VALUEFUNC(OrdRejReason_SURVEILLENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_EXCHCLOSED", VALUEFUNC(OrdRejReason_EXCHCLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", VALUEFUNC(OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_INVINVID", VALUEFUNC(OrdRejReason_INVINVID_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNSUPPORDERCHAR", VALUEFUNC(OrdRejReason_UNSUPPORDERCHAR_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_TRADEALONGREQ", VALUEFUNC(OrdRejReason_TRADEALONGREQ_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_UNKNOWN", VALUEFUNC(OrdRejReason_UNKNOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_TRADE_ALONG_REQUIRED", VALUEFUNC(OrdRejReason_TRADE_ALONG_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdRejReason_STALE_ORDER", VALUEFUNC(OrdRejReason_STALE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_WEEKS", VALUEFUNC(MaturityMonthYearIncrementUnits_WEEKS_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_MONTHS", VALUEFUNC(MaturityMonthYearIncrementUnits_MONTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_YEARS", VALUEFUNC(MaturityMonthYearIncrementUnits_YEARS_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearIncrementUnits_DAYS", VALUEFUNC(MaturityMonthYearIncrementUnits_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayWhen_EXHAUST", VALUEFUNC(DisplayWhen_EXHAUST_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayWhen_IMMEDIATE", VALUEFUNC(DisplayWhen_IMMEDIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_END_SESSION", VALUEFUNC(ApplQueueAction_END_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_QUEUEFLUSHED", VALUEFUNC(ApplQueueAction_QUEUEFLUSHED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_QUEUE_FLUSHED", VALUEFUNC(ApplQueueAction_QUEUE_FLUSHED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_ENDSESSION", VALUEFUNC(ApplQueueAction_ENDSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_OVERLAYLAST", VALUEFUNC(ApplQueueAction_OVERLAYLAST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_OVERLAY_LAST", VALUEFUNC(ApplQueueAction_OVERLAY_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_NOACTIONTAKEN", VALUEFUNC(ApplQueueAction_NOACTIONTAKEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueAction_NO_ACTION_TAKEN", VALUEFUNC(ApplQueueAction_NO_ACTION_TAKEN_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistTransType_REPLACE", VALUEFUNC(RegistTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistTransType_NEW", VALUEFUNC(RegistTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistTransType_CANCEL", VALUEFUNC(RegistTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_HALFS", VALUEFUNC(PriceType_PRODUCT_TICKS_IN_HALFS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_FIXEDCABINETTRADEPRICE", VALUEFUNC(PriceType_FIXEDCABINETTRADEPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PER_SHARE", VALUEFUNC(PriceType_PER_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PCT", VALUEFUNC(PriceType_PCT_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_VARIABLECABINETTRADEPRICE", VALUEFUNC(PriceType_VARIABLECABINETTRADEPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_FOURTHS", VALUEFUNC(PriceType_PRODUCT_TICKS_IN_FOURTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_TEDPRICE", VALUEFUNC(PriceType_TEDPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_YIELD", VALUEFUNC(PriceType_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_TED_YIELD", VALUEFUNC(PriceType_TED_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PREMIUM", VALUEFUNC(PriceType_PREMIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_FIXED_AMOUNT", VALUEFUNC(PriceType_FIXED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_TEDYIELD", VALUEFUNC(PriceType_TEDYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_DISCOUNT", VALUEFUNC(PriceType_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS", VALUEFUNC(PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS", VALUEFUNC(PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_CPS", VALUEFUNC(PriceType_CPS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PERCENTAGE", VALUEFUNC(PriceType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_EIGHTS", VALUEFUNC(PriceType_PRODUCT_TICKS_IN_EIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS", VALUEFUNC(PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_ABS", VALUEFUNC(PriceType_ABS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_VARIABLE_CABINET_TRADE_PRICE", VALUEFUNC(PriceType_VARIABLE_CABINET_TRADE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PER_UNIT", VALUEFUNC(PriceType_PER_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_PRODUCT_TICKS_IN_SIXTEENTHS", VALUEFUNC(PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_TED_PRICE", VALUEFUNC(PriceType_TED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_FIXED_CABINET_TRADE_PRICE", VALUEFUNC(PriceType_FIXED_CABINET_TRADE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_SPREAD", VALUEFUNC(PriceType_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK", VALUEFUNC(PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligMode_PRELIMINARY", VALUEFUNC(SettlObligMode_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligMode_FINAL", VALUEFUNC(SettlObligMode_FINAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityUpdateAction_DELETE", VALUEFUNC(SecurityUpdateAction_DELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityUpdateAction_ADD", VALUEFUNC(SecurityUpdateAction_ADD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityUpdateAction_MODIFY", VALUEFUNC(SecurityUpdateAction_MODIFY_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_STOP_SUBSCRIBING", VALUEFUNC(NetworkRequestType_STOP_SUBSCRIBING_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_LEVELOFDETAIL", VALUEFUNC(NetworkRequestType_LEVELOFDETAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_SUBSCRIBE", VALUEFUNC(NetworkRequestType_SUBSCRIBE_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_SNAPSHOT", VALUEFUNC(NetworkRequestType_SNAPSHOT_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_STOPSUBSCRIBING", VALUEFUNC(NetworkRequestType_STOPSUBSCRIBING_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED", VALUEFUNC(NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_TRADER_MNEMONIC", VALUEFUNC(PartyRole_TRADER_MNEMONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ACCEPTABLE_COUNTERPARTY", VALUEFUNC(PartyRole_ACCEPTABLE_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_HOST_COMPETENT_AUTHORITY", VALUEFUNC(PartyRole_HOST_COMPETENT_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRATRADER", VALUEFUNC(PartyRole_CONTRATRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTINGFIRM", VALUEFUNC(PartyRole_EXECUTINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CUSTOMER_ACCOUNT", VALUEFUNC(PartyRole_CUSTOMER_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_POSITIONACCOUNT", VALUEFUNC(PartyRole_POSITIONACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REPORT_ORIGINATOR", VALUEFUNC(PartyRole_REPORT_ORIGINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRAFIRM", VALUEFUNC(PartyRole_CONTRAFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTION_VENUE", VALUEFUNC(PartyRole_EXECUTION_VENUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTERMEDIARY", VALUEFUNC(PartyRole_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ORDER_ENTRY_OPERATOR_ID", VALUEFUNC(PartyRole_ORDER_ENTRY_OPERATOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTRODUCING_BROKER", VALUEFUNC(PartyRole_INTRODUCING_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_FOREIGN_FIRM", VALUEFUNC(PartyRole_FOREIGN_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_HOME_COMPETENT_AUTHORITY", VALUEFUNC(PartyRole_HOME_COMPETENT_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTINGSYSTEM", VALUEFUNC(PartyRole_EXECUTINGSYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SECONDARY_ACCOUNT_NUMBER", VALUEFUNC(PartyRole_SECONDARY_ACCOUNT_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INVESTMENT_FIRM", VALUEFUNC(PartyRole_INVESTMENT_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_CLEARING_FIRM", VALUEFUNC(PartyRole_CONTRA_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_POSITION_ACCOUNT", VALUEFUNC(PartyRole_CONTRA_POSITION_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SYSTEMATIC_INTERNALISER", VALUEFUNC(PartyRole_SYSTEMATIC_INTERNALISER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXCHANGE", VALUEFUNC(PartyRole_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTERNAL_CARRY_ACCOUNT", VALUEFUNC(PartyRole_INTERNAL_CARRY_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LOCATE", VALUEFUNC(PartyRole_LOCATE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDENTCLEARINGORGANIZATION", VALUEFUNC(PartyRole_CORRESPONDENTCLEARINGORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ORDER_ORIGINATION_TRADER", VALUEFUNC(PartyRole_ORDER_ORIGINATION_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SUB_CUSTODIAN", VALUEFUNC(PartyRole_SUB_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERING_UNIT", VALUEFUNC(PartyRole_ENTERING_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_STEP_OUT_FIRM", VALUEFUNC(PartyRole_STEP_OUT_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION", VALUEFUNC(PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SENDER_LOCATION", VALUEFUNC(PartyRole_SENDER_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REGULATED_MARKET", VALUEFUNC(PartyRole_REGULATED_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY", VALUEFUNC(PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SETTLEMENTLOCATION", VALUEFUNC(PartyRole_SETTLEMENTLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY", VALUEFUNC(PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_QUOTE_ORIGINATOR", VALUEFUNC(PartyRole_QUOTE_ORIGINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARING_ORGANIZATION", VALUEFUNC(PartyRole_CLEARING_ORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SESSION_ID", VALUEFUNC(PartyRole_SESSION_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MARKET_MAKER", VALUEFUNC(PartyRole_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTERESTED_PARTY", VALUEFUNC(PartyRole_INTERESTED_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_TRANSFER_TO_FIRM", VALUEFUNC(PartyRole_TRANSFER_TO_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_TRADER", VALUEFUNC(PartyRole_CONTRA_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERINGTRADER", VALUEFUNC(PartyRole_ENTERINGTRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERING_TRADER", VALUEFUNC(PartyRole_ENTERING_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT", VALUEFUNC(PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BENEFICIARY", VALUEFUNC(PartyRole_BENEFICIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_INVESTOR_ID", VALUEFUNC(PartyRole_CONTRA_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_FORIEGN_FIRM", VALUEFUNC(PartyRole_FORIEGN_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SETTLEMENT_LOCATION", VALUEFUNC(PartyRole_SETTLEMENT_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARINGORGANIZATION", VALUEFUNC(PartyRole_CLEARINGORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_SYSTEM", VALUEFUNC(PartyRole_EXECUTING_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARING_FIRM", VALUEFUNC(PartyRole_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_PLEDGEE_ACCOUNT", VALUEFUNC(PartyRole_PLEDGEE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLIENT_ID", VALUEFUNC(PartyRole_CLIENT_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERING_FIRM", VALUEFUNC(PartyRole_ENTERING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ALLOCENTITY", VALUEFUNC(PartyRole_ALLOCENTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INVESTOR_ID", VALUEFUNC(PartyRole_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARINGFIRM", VALUEFUNC(PartyRole_CLEARINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDANT_CLEARING_FIRM", VALUEFUNC(PartyRole_CORRESPONDANT_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SUBCUSTODIAN", VALUEFUNC(PartyRole_SUBCUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BUYER_SELLER", VALUEFUNC(PartyRole_BUYER_SELLER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLEARING_ACCOUNT", VALUEFUNC(PartyRole_CLEARING_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ENTERINGFIRM", VALUEFUNC(PartyRole_ENTERINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES", VALUEFUNC(PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION", VALUEFUNC(PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY", VALUEFUNC(PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CUSTOMERACCOUNT", VALUEFUNC(PartyRole_CUSTOMERACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MARKET_DATA_ENTRY_ORIGINATOR", VALUEFUNC(PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTRODUCINGFIRM", VALUEFUNC(PartyRole_INTRODUCINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_UNIT", VALUEFUNC(PartyRole_EXECUTING_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CENTRAL_REGISTRATION_DEPOSITORY", VALUEFUNC(PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTERESTEDPARTY", VALUEFUNC(PartyRole_INTERESTEDPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LOCATION_ID", VALUEFUNC(PartyRole_LOCATION_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ORDERORIGINATOR", VALUEFUNC(PartyRole_ORDERORIGINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDENT_BROKER", VALUEFUNC(PartyRole_CORRESPONDENT_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ASSET_MANAGER", VALUEFUNC(PartyRole_ASSET_MANAGER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MULTILATERAL_TRADING_FACILITY", VALUEFUNC(PartyRole_MULTILATERAL_TRADING_FACILITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SPONSORINGFIRM", VALUEFUNC(PartyRole_SPONSORINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ORDER_ORIGINATION_FIRM", VALUEFUNC(PartyRole_ORDER_ORIGINATION_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_EXCHANGE", VALUEFUNC(PartyRole_CONTRA_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INVESTORID", VALUEFUNC(PartyRole_INVESTORID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_FUNDMANAGER", VALUEFUNC(PartyRole_FUNDMANAGER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REGULATORYBODY", VALUEFUNC(PartyRole_REGULATORYBODY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRA_FIRM", VALUEFUNC(PartyRole_CONTRA_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BROKER_OF_CREDIT", VALUEFUNC(PartyRole_BROKER_OF_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LIQUIDITYPROVIDER", VALUEFUNC(PartyRole_LIQUIDITYPROVIDER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_GIVEUPCLEARINGFIRM", VALUEFUNC(PartyRole_GIVEUPCLEARINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CONTRACLEARINGFIRM", VALUEFUNC(PartyRole_CONTRACLEARINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLAIMING_ACCOUNT", VALUEFUNC(PartyRole_CLAIMING_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INTRODUCING_FIRM", VALUEFUNC(PartyRole_INTRODUCING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_GIVEUP_CLEARING_FIRM", VALUEFUNC(PartyRole_GIVEUP_CLEARING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTINGTRADER", VALUEFUNC(PartyRole_EXECUTINGTRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_UNDERLYING_CONTRA_FIRM", VALUEFUNC(PartyRole_UNDERLYING_CONTRA_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_FIRM", VALUEFUNC(PartyRole_EXECUTING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_AGENT", VALUEFUNC(PartyRole_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LIQUIDITY_PROVIDER", VALUEFUNC(PartyRole_LIQUIDITY_PROVIDER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_POSITION_ACCOUNT", VALUEFUNC(PartyRole_POSITION_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BROKEROFCREDIT", VALUEFUNC(PartyRole_BROKEROFCREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_THIRD_PARTY_ALLOCATION_FIRM", VALUEFUNC(PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CLIENTID", VALUEFUNC(PartyRole_CLIENTID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_PLEDGOR_ACCOUNT", VALUEFUNC(PartyRole_PLEDGOR_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REPORTING_INTERMEDIARY", VALUEFUNC(PartyRole_REPORTING_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_EXECUTING_TRADER", VALUEFUNC(PartyRole_EXECUTING_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CUSTODIAN", VALUEFUNC(PartyRole_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BROKERCLEARINGID", VALUEFUNC(PartyRole_BROKERCLEARINGID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDENTBROKER", VALUEFUNC(PartyRole_CORRESPONDENTBROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LOCATE_LENDING_FIRM", VALUEFUNC(PartyRole_LOCATE_LENDING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_INITIATINGTRADER", VALUEFUNC(PartyRole_INITIATINGTRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_REGULATORY_BODY", VALUEFUNC(PartyRole_REGULATORY_BODY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_UNACCEPTABLE_COUNTERPARTY", VALUEFUNC(PartyRole_UNACCEPTABLE_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_CORRESPONDANTCLEARINGFIRM", VALUEFUNC(PartyRole_CORRESPONDANTCLEARINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_FUND_MANAGER_CLIENT_ID", VALUEFUNC(PartyRole_FUND_MANAGER_CLIENT_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_BUYERSELLERRECEIVERDELIVERER", VALUEFUNC(PartyRole_BUYERSELLERRECEIVERDELIVERER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_DESK_ID", VALUEFUNC(PartyRole_DESK_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_ALLOCATION_ENTITY", VALUEFUNC(PartyRole_ALLOCATION_ENTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_MARKET_DATA_MARKET", VALUEFUNC(PartyRole_MARKET_DATA_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_SPONSORING_FIRM", VALUEFUNC(PartyRole_SPONSORING_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_LOCATELENDINGFIRM", VALUEFUNC(PartyRole_LOCATELENDINGFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRole_UNDRCONTRAFIRM", VALUEFUNC(PartyRole_UNDRCONTRAFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "AssignmentMethod_PRO_RATA", VALUEFUNC(AssignmentMethod_PRO_RATA_get), 0);
  rb_define_singleton_method(mQuickfix, "AssignmentMethod_RANDOM", VALUEFUNC(AssignmentMethod_RANDOM_get), 0);
  rb_define_singleton_method(mQuickfix, "AssignmentMethod_PRORATA", VALUEFUNC(AssignmentMethod_PRORATA_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_MONTHYEAR", VALUEFUNC(StrategyParameterType_MONTHYEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TZTIMEONLY", VALUEFUNC(StrategyParameterType_TZTIMEONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_PRICE", VALUEFUNC(StrategyParameterType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_QTY", VALUEFUNC(StrategyParameterType_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_BOOLEAN", VALUEFUNC(StrategyParameterType_BOOLEAN_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_MULTIPLECHARVALUE", VALUEFUNC(StrategyParameterType_MULTIPLECHARVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_CHAR", VALUEFUNC(StrategyParameterType_CHAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_NUMINGROUP", VALUEFUNC(StrategyParameterType_NUMINGROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TAGNUM", VALUEFUNC(StrategyParameterType_TAGNUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_COUNTRY", VALUEFUNC(StrategyParameterType_COUNTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TENOR", VALUEFUNC(StrategyParameterType_TENOR_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LOCALMKTTIME", VALUEFUNC(StrategyParameterType_LOCALMKTTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_INT", VALUEFUNC(StrategyParameterType_INT_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LOCALMKTDATE", VALUEFUNC(StrategyParameterType_LOCALMKTDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_EXCHANGE", VALUEFUNC(StrategyParameterType_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LANGUAGE", VALUEFUNC(StrategyParameterType_LANGUAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_MONTH_YEAR", VALUEFUNC(StrategyParameterType_MONTH_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_PERCENTAGE", VALUEFUNC(StrategyParameterType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_LENGTH", VALUEFUNC(StrategyParameterType_LENGTH_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_TZTIMESTAMP", VALUEFUNC(StrategyParameterType_TZTIMESTAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_MULTIPLESTRINGVALUE", VALUEFUNC(StrategyParameterType_MULTIPLESTRINGVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCTIMESTAMP", VALUEFUNC(StrategyParameterType_UTCTIMESTAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_DATA", VALUEFUNC(StrategyParameterType_DATA_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_CURRENCY", VALUEFUNC(StrategyParameterType_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_STRING", VALUEFUNC(StrategyParameterType_STRING_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_AMT", VALUEFUNC(StrategyParameterType_AMT_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_FLOAT", VALUEFUNC(StrategyParameterType_FLOAT_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCDATE", VALUEFUNC(StrategyParameterType_UTCDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCTIMEONLY", VALUEFUNC(StrategyParameterType_UTCTIMEONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_SEQNUM", VALUEFUNC(StrategyParameterType_SEQNUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_UTCDATEONLY", VALUEFUNC(StrategyParameterType_UTCDATEONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "StrategyParameterType_PRICEOFFSET", VALUEFUNC(StrategyParameterType_PRICEOFFSET_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PGP_DES_MD5", VALUEFUNC(EncryptMethod_PGP_DES_MD5_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE", VALUEFUNC(EncryptMethod_PGPDESMD5SEEAPPNOTEONFIXWEBSITE_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PKCS_DES", VALUEFUNC(EncryptMethod_PKCS_DES_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_NONEOTHER", VALUEFUNC(EncryptMethod_NONEOTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PKCSDESPROPRIETARY", VALUEFUNC(EncryptMethod_PKCSDESPROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PGPDESDEFUNCT", VALUEFUNC(EncryptMethod_PGPDESDEFUNCT_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED", VALUEFUNC(EncryptMethod_PEMDESMD5SEEAPPNOTEONFIXWEBSITENAFORFIXMLNOTUSED_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PKCS", VALUEFUNC(EncryptMethod_PKCS_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PGP_DES", VALUEFUNC(EncryptMethod_PGP_DES_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_NONE", VALUEFUNC(EncryptMethod_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_DES", VALUEFUNC(EncryptMethod_DES_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PKCSPROPRIETARY", VALUEFUNC(EncryptMethod_PKCSPROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_NONE_OTHER", VALUEFUNC(EncryptMethod_NONE_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_DESECBMODE", VALUEFUNC(EncryptMethod_DESECBMODE_get), 0);
  rb_define_singleton_method(mQuickfix, "EncryptMethod_PEM_DES_MD5", VALUEFUNC(EncryptMethod_PEM_DES_MD5_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_ACCRUED_COUPON_AMOUNT", VALUEFUNC(PosAmtType_ACCRUED_COUPON_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_PREMIUM_AMOUNT", VALUEFUNC(PosAmtType_PREMIUM_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT", VALUEFUNC(PosAmtType_STARTOFDAYMARKTOMARKETAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INCREMENTALMARKTOMARKETAMOUNT", VALUEFUNC(PosAmtType_INCREMENTALMARKTOMARKETAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_CASHAMOUNTCORPORATEEVENT", VALUEFUNC(PosAmtType_CASHAMOUNTCORPORATEEVENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET", VALUEFUNC(PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_TOTAL_BANKED_AMOUNT", VALUEFUNC(PosAmtType_TOTAL_BANKED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT", VALUEFUNC(PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_SETTLEMENT_VALUE", VALUEFUNC(PosAmtType_SETTLEMENT_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_VALUEADJUSTEDAMOUNT", VALUEFUNC(PosAmtType_VALUEADJUSTEDAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_CASH_AMOUNT", VALUEFUNC(PosAmtType_CASH_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_PREMIUMAMOUNT", VALUEFUNC(PosAmtType_PREMIUMAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INITIAL_TRADE_COUPON_AMOUNT", VALUEFUNC(PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INCREMENTAL_ACCRUED_COUPON", VALUEFUNC(PosAmtType_INCREMENTAL_ACCRUED_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT", VALUEFUNC(PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_VALUE_ADJUSTED_AMOUNT", VALUEFUNC(PosAmtType_VALUE_ADJUSTED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_CASHRESIDUALAMOUNT", VALUEFUNC(PosAmtType_CASHRESIDUALAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_COLLATERALIZED_MARK_TO_MARKET", VALUEFUNC(PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_CASH_RESIDUAL_AMOUNT", VALUEFUNC(PosAmtType_CASH_RESIDUAL_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_COMPENSATION_AMOUNT", VALUEFUNC(PosAmtType_COMPENSATION_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_TRADE_VARIATION_AMOUNT", VALUEFUNC(PosAmtType_TRADE_VARIATION_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_TRADEVARIATIONAMOUNT", VALUEFUNC(PosAmtType_TRADEVARIATIONAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_FINALMARKTOMARKETAMOUNT", VALUEFUNC(PosAmtType_FINALMARKTOMARKETAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_COUPON_AMOUNT", VALUEFUNC(PosAmtType_COUPON_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_TOTAL_COLLATERALIZED_AMOUNT", VALUEFUNC(PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT", VALUEFUNC(PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ResetSeqNumFlag_NO", VALUEFUNC(ResetSeqNumFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ResetSeqNumFlag_YES", VALUEFUNC(ResetSeqNumFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED", VALUEFUNC(CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED", VALUEFUNC(CollInquiryResult_NOCOLLATERALFOUNDFORTHEORDERSPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED", VALUEFUNC(CollInquiryResult_NOCOLLATERALFOUNDFORTHETRADESPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT", VALUEFUNC(CollInquiryResult_INVALIDORUNKNOWNINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_DESTINATION_REQUESTED", VALUEFUNC(CollInquiryResult_INVALID_DESTINATION_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE", VALUEFUNC(CollInquiryResult_INVALIDORUNKNOWNCOLLATERALTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY", VALUEFUNC(CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED", VALUEFUNC(CollInquiryResult_INVALIDTRANSPORTTYPEREQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALIDPARTIES", VALUEFUNC(CollInquiryResult_INVALIDPARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE", VALUEFUNC(CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALIDDESTINATIONREQUESTED", VALUEFUNC(CollInquiryResult_INVALIDDESTINATIONREQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_SUCCESSFUL", VALUEFUNC(CollInquiryResult_SUCCESSFUL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT", VALUEFUNC(CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED", VALUEFUNC(CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_OTHER", VALUEFUNC(CollInquiryResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY", VALUEFUNC(CollInquiryResult_UNAUTHORIZEDFORCOLLATERALINQUIRY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED", VALUEFUNC(CollInquiryResult_COLLATERALINQUIRYTYPENOTSUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_PARTIES", VALUEFUNC(CollInquiryResult_INVALID_PARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED", VALUEFUNC(CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED", VALUEFUNC(CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_DECLINED", VALUEFUNC(CollAsgnRespType_DECLINED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_RECEIVED", VALUEFUNC(CollAsgnRespType_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_REJECTED", VALUEFUNC(CollAsgnRespType_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRespType_ACCEPTED", VALUEFUNC(CollAsgnRespType_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "UnsolicitedIndicator_NO", VALUEFUNC(UnsolicitedIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "UnsolicitedIndicator_YES", VALUEFUNC(UnsolicitedIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_UNKNWNSYM", VALUEFUNC(QuoteEntryRejectReason_UNKNWNSYM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_EXCHCLSD", VALUEFUNC(QuoteEntryRejectReason_EXCHCLSD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_EXHCNAGE", VALUEFUNC(QuoteEntryRejectReason_EXHCNAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_DUPORD", VALUEFUNC(QuoteEntryRejectReason_DUPORD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_INVALID_PRICE", VALUEFUNC(QuoteEntryRejectReason_INVALID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_TOOLATE", VALUEFUNC(QuoteEntryRejectReason_TOOLATE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_INVBIDASK", VALUEFUNC(QuoteEntryRejectReason_INVBIDASK_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY", VALUEFUNC(QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT", VALUEFUNC(QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_ORDEXCLIM", VALUEFUNC(QuoteEntryRejectReason_ORDEXCLIM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_UNKNORD", VALUEFUNC(QuoteEntryRejectReason_UNKNORD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_INVPX", VALUEFUNC(QuoteEntryRejectReason_INVPX_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_EXCHANGE", VALUEFUNC(QuoteEntryRejectReason_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_UNKNOWN_SYMBOL", VALUEFUNC(QuoteEntryRejectReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_NOTAUTH", VALUEFUNC(QuoteEntryRejectReason_NOTAUTH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_OTHER", VALUEFUNC(QuoteEntryRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD", VALUEFUNC(QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_UNKNOWN_QUOTE", VALUEFUNC(QuoteEntryRejectReason_UNKNOWN_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryRejectReason_DUPLICATE_QUOTE", VALUEFUNC(QuoteEntryRejectReason_DUPLICATE_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_PROPRIETARY", VALUEFUNC(OrderCapacity_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_RISKLESS_PRINCIPAL", VALUEFUNC(OrderCapacity_RISKLESS_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_AGENT_FOR_OTHER_MEMBER", VALUEFUNC(OrderCapacity_AGENT_FOR_OTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_PRINCIPAL", VALUEFUNC(OrderCapacity_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_AGENCY", VALUEFUNC(OrderCapacity_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_INDIVIDUAL", VALUEFUNC(OrderCapacity_INDIVIDUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_AGENTOTHERMEMBER", VALUEFUNC(OrderCapacity_AGENTOTHERMEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCapacity_RISKLESSPRINCIPAL", VALUEFUNC(OrderCapacity_RISKLESSPRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_FOR_UNDERLYING", VALUEFUNC(QuoteAckStatus_CANCELED_FOR_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_ALL", VALUEFUNC(QuoteAckStatus_CANCELED_ALL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE", VALUEFUNC(QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_REJECTED", VALUEFUNC(QuoteAckStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_CANCELED_FOR_SYMBOL", VALUEFUNC(QuoteAckStatus_CANCELED_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteAckStatus_ACCEPTED", VALUEFUNC(QuoteAckStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_CHANGE_PASSWORD_FOR_USER", VALUEFUNC(UserRequestType_CHANGE_PASSWORD_FOR_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_CHANGEPASSWORDFORUSER", VALUEFUNC(UserRequestType_CHANGEPASSWORDFORUSER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOGOFFUSER", VALUEFUNC(UserRequestType_LOGOFFUSER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOG_OFF_USER", VALUEFUNC(UserRequestType_LOG_OFF_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS", VALUEFUNC(UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_REQUESTINDIVIDUALUSERSTATUS", VALUEFUNC(UserRequestType_REQUESTINDIVIDUALUSERSTATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOGONUSER", VALUEFUNC(UserRequestType_LOGONUSER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserRequestType_LOG_ON_USER", VALUEFUNC(UserRequestType_LOG_ON_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_REPLACE", VALUEFUNC(TradeReportTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_NEW", VALUEFUNC(TradeReportTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_REVERSE", VALUEFUNC(TradeReportTransType_REVERSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_CANCEL", VALUEFUNC(TradeReportTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE", VALUEFUNC(TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportTransType_RELEASE", VALUEFUNC(TradeReportTransType_RELEASE_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_CROSS", VALUEFUNC(AdvSide_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_TRADE", VALUEFUNC(AdvSide_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_BUY", VALUEFUNC(AdvSide_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvSide_SELL", VALUEFUNC(AdvSide_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "CoveredOrUncovered_COVERED", VALUEFUNC(CoveredOrUncovered_COVERED_get), 0);
  rb_define_singleton_method(mQuickfix, "CoveredOrUncovered_UNCOVERED", VALUEFUNC(CoveredOrUncovered_UNCOVERED_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_TFMGSPTA", VALUEFUNC(AcctIDSource_TFMGSPTA_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_TFM", VALUEFUNC(AcctIDSource_TFM_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_DTCCCODE", VALUEFUNC(AcctIDSource_DTCCCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_SIDCODE", VALUEFUNC(AcctIDSource_SIDCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_OMGEOALERTID", VALUEFUNC(AcctIDSource_OMGEOALERTID_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_BIC", VALUEFUNC(AcctIDSource_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_OTHER", VALUEFUNC(AcctIDSource_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_OMGEO", VALUEFUNC(AcctIDSource_OMGEO_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_SID_CODE", VALUEFUNC(AcctIDSource_SID_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "AcctIDSource_DTCC_CODE", VALUEFUNC(AcctIDSource_DTCC_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA", VALUEFUNC(TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_ALL_TRADES", VALUEFUNC(TradeRequestType_ALL_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST", VALUEFUNC(TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_UNREPORTEDTRADES", VALUEFUNC(TradeRequestType_UNREPORTEDTRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_ALLTRADES", VALUEFUNC(TradeRequestType_ALLTRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_ADVISORIESMATCH", VALUEFUNC(TradeRequestType_ADVISORIESMATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_MATCHEDTRADES", VALUEFUNC(TradeRequestType_MATCHEDTRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_UNMATCHEDTRADES", VALUEFUNC(TradeRequestType_UNMATCHEDTRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA", VALUEFUNC(TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA", VALUEFUNC(TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_PRECLOSE", VALUEFUNC(TradSesStatus_PRECLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_HALTED", VALUEFUNC(TradSesStatus_HALTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_REQREJ", VALUEFUNC(TradSesStatus_REQREJ_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_REQUEST_REJECTED", VALUEFUNC(TradSesStatus_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_OPEN", VALUEFUNC(TradSesStatus_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_PREOPEN", VALUEFUNC(TradSesStatus_PREOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_PRE_OPEN", VALUEFUNC(TradSesStatus_PRE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_UNKNOWN", VALUEFUNC(TradSesStatus_UNKNOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_PRE_CLOSE", VALUEFUNC(TradSesStatus_PRE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatus_CLOSED", VALUEFUNC(TradSesStatus_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_LAST_PEG", VALUEFUNC(PegPriceType_LAST_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_PRIMARY_PEG", VALUEFUNC(PegPriceType_PRIMARY_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_OPENING_PEG", VALUEFUNC(PegPriceType_OPENING_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER", VALUEFUNC(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(PegPriceType_TRAILING_STOP_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_PEG_TO_LIMIT_PRICE", VALUEFUNC(PegPriceType_PEG_TO_LIMIT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_MID_PRICE_PEG", VALUEFUNC(PegPriceType_MID_PRICE_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_MARKET_PEG", VALUEFUNC(PegPriceType_MARKET_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "PegPriceType_PEG_TO_VWAP", VALUEFUNC(PegPriceType_PEG_TO_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_NO_AVAILABLE_STREAM", VALUEFUNC(StreamAsgnRejReason_NO_AVAILABLE_STREAM_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE", VALUEFUNC(StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_UNKNOWN_CLIENT", VALUEFUNC(StreamAsgnRejReason_UNKNOWN_CLIENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR", VALUEFUNC(StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnRejReason_OTHER", VALUEFUNC(StreamAsgnRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT", VALUEFUNC(ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_PREMIUM_STYLE", VALUEFUNC(ValuationMethod_PREMIUM_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_CDS_IN_DELIVERY", VALUEFUNC(ValuationMethod_CDS_IN_DELIVERY_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON", VALUEFUNC(ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET", VALUEFUNC(ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_SPECIFIED_TRADING_SESSION", VALUEFUNC(TriggerType_SPECIFIED_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_NEXT_AUCTION", VALUEFUNC(TriggerType_NEXT_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_PRICE_MOVEMENT", VALUEFUNC(TriggerType_PRICE_MOVEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerType_PARTIAL_EXECUTION", VALUEFUNC(TriggerType_PARTIAL_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_LOCAL", VALUEFUNC(PriceProtectionScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_NONE", VALUEFUNC(PriceProtectionScope_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_GLOBAL", VALUEFUNC(PriceProtectionScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceProtectionScope_NATIONAL", VALUEFUNC(PriceProtectionScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_SUCCESSFULDEFAULT", VALUEFUNC(TradeReportRejectReason_SUCCESSFULDEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES", VALUEFUNC(TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_SUCCESSFUL", VALUEFUNC(TradeReportRejectReason_SUCCESSFUL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_INVALID_PARTY_ONFORMATION", VALUEFUNC(TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_UNKNOWN_INSTRUMENT", VALUEFUNC(TradeReportRejectReason_UNKNOWN_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_OTHER", VALUEFUNC(TradeReportRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_INVALIDTRADETYPE", VALUEFUNC(TradeReportRejectReason_INVALIDTRADETYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_UNKNOWNINSTRUMENT", VALUEFUNC(TradeReportRejectReason_UNKNOWNINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_INVALID_TRADE_TYPE", VALUEFUNC(TradeReportRejectReason_INVALID_TRADE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES", VALUEFUNC(TradeReportRejectReason_UNAUTHORIZEDTOREPORTTRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportRejectReason_INVALIDPARTYINFORMATION", VALUEFUNC(TradeReportRejectReason_INVALIDPARTYINFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_NEWSPAPER_LIST", VALUEFUNC(SecurityListType_NEWSPAPER_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_TRADING_LIST", VALUEFUNC(SecurityListType_TRADING_LIST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_INDUSTRY_CLASSIFICATION", VALUEFUNC(SecurityListType_INDUSTRY_CLASSIFICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListType_MARKET", VALUEFUNC(SecurityListType_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_QUOTE_LOCKED", VALUEFUNC(QuoteRejectReason_QUOTE_LOCKED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_UNKNSYM", VALUEFUNC(QuoteRejectReason_UNKNSYM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_EXCHCLSD", VALUEFUNC(QuoteRejectReason_EXCHCLSD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_DUPORD", VALUEFUNC(QuoteRejectReason_DUPORD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_PRICE", VALUEFUNC(QuoteRejectReason_INVALID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_TOOLATE", VALUEFUNC(QuoteRejectReason_TOOLATE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY", VALUEFUNC(QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(QuoteRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_UNKNORD", VALUEFUNC(QuoteRejectReason_UNKNORD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVPX", VALUEFUNC(QuoteRejectReason_INVPX_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_EXCHANGE", VALUEFUNC(QuoteRejectReason_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVSPREAD", VALUEFUNC(QuoteRejectReason_INVSPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_UNKNOWN_SYMBOL", VALUEFUNC(QuoteRejectReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_NOTAUTH", VALUEFUNC(QuoteRejectReason_NOTAUTH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_OTHER", VALUEFUNC(QuoteRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_BID_ASK_SPREAD", VALUEFUNC(QuoteRejectReason_INVALID_BID_ASK_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_UNKNOWN_QUOTE", VALUEFUNC(QuoteRejectReason_UNKNOWN_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", VALUEFUNC(QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_ORDEXLIM", VALUEFUNC(QuoteRejectReason_ORDEXLIM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_DUPLICATE_QUOTE", VALUEFUNC(QuoteRejectReason_DUPLICATE_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", VALUEFUNC(QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT", VALUEFUNC(QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PossResend_NO", VALUEFUNC(PossResend_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PossResend_YES", VALUEFUNC(PossResend_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_SHARES", VALUEFUNC(QuantityType_SHARES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_CURRENTFACE", VALUEFUNC(QuantityType_CURRENTFACE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_PAR", VALUEFUNC(QuantityType_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_BONDS", VALUEFUNC(QuantityType_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_ORIGINALFACE", VALUEFUNC(QuantityType_ORIGINALFACE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_CONTRACTS", VALUEFUNC(QuantityType_CONTRACTS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_OTHER", VALUEFUNC(QuantityType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuantityType_CURRENCY", VALUEFUNC(QuantityType_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE", VALUEFUNC(ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE", VALUEFUNC(ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE", VALUEFUNC(ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE", VALUEFUNC(ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE", VALUEFUNC(ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT", VALUEFUNC(ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_NOT_IMPLIED", VALUEFUNC(ImpliedMarketIndicator_NOT_IMPLIED_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_IMPLIED_OUT", VALUEFUNC(ImpliedMarketIndicator_IMPLIED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ImpliedMarketIndicator_IMPLIED_IN", VALUEFUNC(ImpliedMarketIndicator_IMPLIED_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestType_AUTOMATIC", VALUEFUNC(QuoteRequestType_AUTOMATIC_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestType_MAN", VALUEFUNC(QuoteRequestType_MAN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestType_AUTO", VALUEFUNC(QuoteRequestType_AUTO_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestType_MANUAL", VALUEFUNC(QuoteRequestType_MANUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_INSTRUMENTUNAVAILABLE", VALUEFUNC(SecurityRequestResult_INSTRUMENTUNAVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA", VALUEFUNC(SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA", VALUEFUNC(SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE", VALUEFUNC(SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_VALID_REQUEST", VALUEFUNC(SecurityRequestResult_VALID_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_VALIDREQ", VALUEFUNC(SecurityRequestResult_VALIDREQ_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_NOINSTRUMENTSFOUND", VALUEFUNC(SecurityRequestResult_NOINSTRUMENTSFOUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST", VALUEFUNC(SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_NOTAUTHORIZED", VALUEFUNC(SecurityRequestResult_NOTAUTHORIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_NOTSUPPORTED", VALUEFUNC(SecurityRequestResult_NOTSUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_INVALIDREQ", VALUEFUNC(SecurityRequestResult_INVALIDREQ_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED", VALUEFUNC(SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ISSUER_HOLDING", VALUEFUNC(OrderRestrictions_ISSUER_HOLDING_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_NON_INDEXARBITRAGE", VALUEFUNC(OrderRestrictions_NON_INDEXARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXMRKTPART", VALUEFUNC(OrderRestrictions_EXMRKTPART_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY", VALUEFUNC(OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_NON_ALGORITHMIC", VALUEFUNC(OrderRestrictions_NON_ALGORITHMIC_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE", VALUEFUNC(OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_NON_INDEX_ARBITRAGE", VALUEFUNC(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(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(OrderRestrictions_PROGRAM_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ISSUE_PRICE_STABILIZATION", VALUEFUNC(OrderRestrictions_ISSUE_PRICE_STABILIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_INDEXARBITRAGE", VALUEFUNC(OrderRestrictions_INDEXARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ACTMMDERIV", VALUEFUNC(OrderRestrictions_ACTMMDERIV_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_FORENTITY", VALUEFUNC(OrderRestrictions_FORENTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_CROSS", VALUEFUNC(OrderRestrictions_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_PROGRAMTRADE", VALUEFUNC(OrderRestrictions_PROGRAMTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_RISKARB", VALUEFUNC(OrderRestrictions_RISKARB_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE", VALUEFUNC(OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_FOREIGN_ENTITY", VALUEFUNC(OrderRestrictions_FOREIGN_ENTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_COMPETINGMARKETMAKER", VALUEFUNC(OrderRestrictions_COMPETINGMARKETMAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXINTMRKTLINK", VALUEFUNC(OrderRestrictions_EXINTMRKTLINK_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_INDEX_ARBITRAGE", VALUEFUNC(OrderRestrictions_INDEX_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT", VALUEFUNC(OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ALGORITHMIC", VALUEFUNC(OrderRestrictions_ALGORITHMIC_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ACTMM", VALUEFUNC(OrderRestrictions_ACTMM_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY", VALUEFUNC(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(OrderRestrictions_RISKLESS_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderRestrictions_COMPETING_MARKET_MAKER", VALUEFUNC(OrderRestrictions_COMPETING_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION", VALUEFUNC(ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN", VALUEFUNC(ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_IMMED", VALUEFUNC(ListExecInstType_IMMED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_WAIT", VALUEFUNC(ListExecInstType_WAIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW", VALUEFUNC(ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3", VALUEFUNC(ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_IMMEDIATE", VALUEFUNC(ListExecInstType_IMMEDIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4", VALUEFUNC(ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5", VALUEFUNC(ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP", VALUEFUNC(ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHCIVBUYTOP", VALUEFUNC(ListExecInstType_EXCHCIVBUYTOP_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHCIVBUYWD", VALUEFUNC(ListExecInstType_EXCHCIVBUYWD_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_EXCHCIVSELL", VALUEFUNC(ListExecInstType_EXCHCIVSELL_get), 0);
  rb_define_singleton_method(mQuickfix, "ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION", VALUEFUNC(ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_FED_WIRE", VALUEFUNC(DistribPaymentMethod_FED_WIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_ACH_CREDIT", VALUEFUNC(DistribPaymentMethod_ACH_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_EUROCLEAR", VALUEFUNC(DistribPaymentMethod_EUROCLEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_TELEGRAPHICTRANSFER", VALUEFUNC(DistribPaymentMethod_TELEGRAPHICTRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_ACHCREDIT", VALUEFUNC(DistribPaymentMethod_ACHCREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_TELEGRAPHIC_TRANSFER", VALUEFUNC(DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_FEDWIRE", VALUEFUNC(DistribPaymentMethod_FEDWIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_CHEQUE", VALUEFUNC(DistribPaymentMethod_CHEQUE_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_DIRECT_CREDIT", VALUEFUNC(DistribPaymentMethod_DIRECT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_CREST", VALUEFUNC(DistribPaymentMethod_CREST_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_BPAY", VALUEFUNC(DistribPaymentMethod_BPAY_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_CLEARSTREAM", VALUEFUNC(DistribPaymentMethod_CLEARSTREAM_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_DIRECTCREDITBECSBACS", VALUEFUNC(DistribPaymentMethod_DIRECTCREDITBECSBACS_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS", VALUEFUNC(DistribPaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_NSCC", VALUEFUNC(DistribPaymentMethod_NSCC_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS", VALUEFUNC(DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_REINVESTINFUND", VALUEFUNC(DistribPaymentMethod_REINVESTINFUND_get), 0);
  rb_define_singleton_method(mQuickfix, "DistribPaymentMethod_REINVEST_IN_FUND", VALUEFUNC(DistribPaymentMethod_REINVEST_IN_FUND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderHandlingInstSource_NASD_OATS", VALUEFUNC(OrderHandlingInstSource_NASD_OATS_get), 0);
  rb_define_singleton_method(mQuickfix, "AffirmStatus_CONFIRMREJECTED", VALUEFUNC(AffirmStatus_CONFIRMREJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED", VALUEFUNC(AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "AffirmStatus_AFFIRMED", VALUEFUNC(AffirmStatus_AFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "AffirmStatus_RECEIVED", VALUEFUNC(AffirmStatus_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT", VALUEFUNC(OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT", VALUEFUNC(OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER", VALUEFUNC(OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrigCustOrderCapacity_ALL_OTHER", VALUEFUNC(OrigCustOrderCapacity_ALL_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocMethod_GUARANTOR", VALUEFUNC(AllocMethod_GUARANTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocMethod_AUTOMATIC", VALUEFUNC(AllocMethod_AUTOMATIC_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocMethod_MANUAL", VALUEFUNC(AllocMethod_MANUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLORDERSSECURITYTYPE", VALUEFUNC(MassCancelResponse_CXLORDERSSECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLORDERSUNDERLYINGSECURITY", VALUEFUNC(MassCancelResponse_CXLORDERSUNDERLYINGSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLORDERSTRDSESSION", VALUEFUNC(MassCancelResponse_CXLORDERSTRDSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLALLORDERS", VALUEFUNC(MassCancelResponse_CXLALLORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLREQREJ", VALUEFUNC(MassCancelResponse_CXLREQREJ_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLORDERSSECURITY", VALUEFUNC(MassCancelResponse_CXLORDERSSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLORDERSPRODUCT", VALUEFUNC(MassCancelResponse_CXLORDERSPRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ALL_ORDERS", VALUEFUNC(MassCancelResponse_CANCEL_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_REQUEST_REJECTED", VALUEFUNC(MassCancelResponse_CANCEL_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CXLORDERSCFICODE", VALUEFUNC(MassCancelResponse_CXLORDERSCFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT", VALUEFUNC(MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER", VALUEFUNC(StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER", VALUEFUNC(StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE", VALUEFUNC(SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "SymbolSfx_EUCPLUMPSUMINTEREST", VALUEFUNC(SymbolSfx_EUCPLUMPSUMINTEREST_get), 0);
  rb_define_singleton_method(mQuickfix, "SymbolSfx_WHENISSUED", VALUEFUNC(SymbolSfx_WHENISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN", VALUEFUNC(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(ExDestinationIDSource_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER", VALUEFUNC(ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_BIC", VALUEFUNC(ExDestinationIDSource_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_MIC", VALUEFUNC(ExDestinationIDSource_MIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestinationIDSource_ISO_COUNTRY_CODE", VALUEFUNC(ExDestinationIDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_ALLSECURITIES", VALUEFUNC(SecurityListRequestType_ALLSECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID", VALUEFUNC(SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_SECURITYTYPECFICODE", VALUEFUNC(SecurityListRequestType_SECURITYTYPECFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_SYMBOL", VALUEFUNC(SecurityListRequestType_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE", VALUEFUNC(SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_TRADINGSESSIONID", VALUEFUNC(SecurityListRequestType_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_ALL_SECURITIES", VALUEFUNC(SecurityListRequestType_ALL_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityListRequestType_PRODUCT", VALUEFUNC(SecurityListRequestType_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_FORWARDCOLLATERALDEMAND", VALUEFUNC(CollAsgnReason_FORWARDCOLLATERALDEMAND_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_ADVERSETAXEVENT", VALUEFUNC(CollAsgnReason_ADVERSETAXEVENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_MARGINDEFICIENCY", VALUEFUNC(CollAsgnReason_MARGINDEFICIENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_TIME_WARNING", VALUEFUNC(CollAsgnReason_TIME_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_TIMEWARNING", VALUEFUNC(CollAsgnReason_TIMEWARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_ADVERSE_TAX_EVENT", VALUEFUNC(CollAsgnReason_ADVERSE_TAX_EVENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_MARGINEXCESS", VALUEFUNC(CollAsgnReason_MARGINEXCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_MARGIN_DEFICIENCY", VALUEFUNC(CollAsgnReason_MARGIN_DEFICIENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_SCHEDULED", VALUEFUNC(CollAsgnReason_SCHEDULED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_INITIAL", VALUEFUNC(CollAsgnReason_INITIAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_FORWARD_COLLATERAL_DEMAND", VALUEFUNC(CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_EVENTOFDEFAULT", VALUEFUNC(CollAsgnReason_EVENTOFDEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_MARGIN_EXCESS", VALUEFUNC(CollAsgnReason_MARGIN_EXCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnReason_EVENT_OF_DEFAULT", VALUEFUNC(CollAsgnReason_EVENT_OF_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlPriceType_FINAL", VALUEFUNC(SettlPriceType_FINAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlPriceType_THEORETICAL", VALUEFUNC(SettlPriceType_THEORETICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DealingCapacity_RISKLESS_PRINCIPAL", VALUEFUNC(DealingCapacity_RISKLESS_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DealingCapacity_PRINCIPAL", VALUEFUNC(DealingCapacity_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DealingCapacity_AGENT", VALUEFUNC(DealingCapacity_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSourceType_SECONDARY", VALUEFUNC(RateSourceType_SECONDARY_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSourceType_PRIMARY", VALUEFUNC(RateSourceType_PRIMARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AggregatedBook_NO", VALUEFUNC(AggregatedBook_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "AggregatedBook_YES", VALUEFUNC(AggregatedBook_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "PosQtyStatus_SUBMITTED", VALUEFUNC(PosQtyStatus_SUBMITTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosQtyStatus_REJECTED", VALUEFUNC(PosQtyStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosQtyStatus_ACCEPTED", VALUEFUNC(PosQtyStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionStatusRequest", VALUEFUNC(MsgType_TradingSessionStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListStatus", VALUEFUNC(MsgType_ListStatus_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Email", VALUEFUNC(MsgType_Email_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListExecute", VALUEFUNC(MsgType_ListExecute_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Confirmation", VALUEFUNC(MsgType_Confirmation_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderMultileg", VALUEFUNC(MsgType_NewOrderMultileg_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_IndicationofInterest", VALUEFUNC(MsgType_IndicationofInterest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataIncrementalRefresh", VALUEFUNC(MsgType_MarketDataIncrementalRefresh_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReport", VALUEFUNC(MsgType_TradeCaptureReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RequestForPositionsAck", VALUEFUNC(MsgType_RequestForPositionsAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_StreamAssignmentRequest", VALUEFUNC(MsgType_StreamAssignmentRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityListRequest", VALUEFUNC(MsgType_SecurityListRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralReport", VALUEFUNC(MsgType_CollateralReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PositionMaintenanceReport", VALUEFUNC(MsgType_PositionMaintenanceReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PositionReport", VALUEFUNC(MsgType_PositionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_StreamAssignmentReportACK", VALUEFUNC(MsgType_StreamAssignmentReportACK_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_UserRequest", VALUEFUNC(MsgType_UserRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PositionMaintenanceRequest", VALUEFUNC(MsgType_PositionMaintenanceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NetworkCounterpartySystemStatusResponse", VALUEFUNC(MsgType_NetworkCounterpartySystemStatusResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderCross", VALUEFUNC(MsgType_NewOrderCross_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AdjustedPositionReport", VALUEFUNC(MsgType_AdjustedPositionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Logon", VALUEFUNC(MsgType_Logon_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_IOI", VALUEFUNC(MsgType_IOI_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListStrikePrice", VALUEFUNC(MsgType_ListStrikePrice_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_BidRequest", VALUEFUNC(MsgType_BidRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionStatus", VALUEFUNC(MsgType_TradingSessionStatus_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RegistrationInstructionsResponse", VALUEFUNC(MsgType_RegistrationInstructionsResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Advertisement", VALUEFUNC(MsgType_Advertisement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MassQuote", VALUEFUNC(MsgType_MassQuote_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Logout", VALUEFUNC(MsgType_Logout_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationReport", VALUEFUNC(MsgType_AllocationReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityDefinitionUpdateReport", VALUEFUNC(MsgType_SecurityDefinitionUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListStatusRequest", VALUEFUNC(MsgType_ListStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_BusinessMessageReject", VALUEFUNC(MsgType_BusinessMessageReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ConfirmationAck", VALUEFUNC(MsgType_ConfirmationAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TestRequest", VALUEFUNC(MsgType_TestRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityList", VALUEFUNC(MsgType_SecurityList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ListCancelRequest", VALUEFUNC(MsgType_ListCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_News", VALUEFUNC(MsgType_News_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionListUpdateReport", VALUEFUNC(MsgType_TradingSessionListUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Heartbeat", VALUEFUNC(MsgType_Heartbeat_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteAcknowledgement", VALUEFUNC(MsgType_QuoteAcknowledgement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationReportAck", VALUEFUNC(MsgType_AllocationReportAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ConfirmationRequest", VALUEFUNC(MsgType_ConfirmationRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassActionReport", VALUEFUNC(MsgType_OrderMassActionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralInquiry", VALUEFUNC(MsgType_CollateralInquiry_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityTypeRequest", VALUEFUNC(MsgType_SecurityTypeRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderList", VALUEFUNC(MsgType_NewOrderList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ExecutionAcknowledgement", VALUEFUNC(MsgType_ExecutionAcknowledgement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionListRequest", VALUEFUNC(MsgType_TradingSessionListRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityTypes", VALUEFUNC(MsgType_SecurityTypes_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDefinition", VALUEFUNC(MsgType_MarketDefinition_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SequenceReset", VALUEFUNC(MsgType_SequenceReset_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralResponse", VALUEFUNC(MsgType_CollateralResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MassQuoteAcknowledgement", VALUEFUNC(MsgType_MassQuoteAcknowledgement_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteResponse", VALUEFUNC(MsgType_QuoteResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteStatusRequest", VALUEFUNC(MsgType_QuoteStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteCancel", VALUEFUNC(MsgType_QuoteCancel_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ContraryIntentionReport", VALUEFUNC(MsgType_ContraryIntentionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PartyDetailsListReport", VALUEFUNC(MsgType_PartyDetailsListReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_PartyDetailsListRequest", VALUEFUNC(MsgType_PartyDetailsListRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CrossOrderCancelRequest", VALUEFUNC(MsgType_CrossOrderCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NewOrderSingle", VALUEFUNC(MsgType_NewOrderSingle_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DerivativeSecurityListRequest", VALUEFUNC(MsgType_DerivativeSecurityListRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralRequest", VALUEFUNC(MsgType_CollateralRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_UserNotification", VALUEFUNC(MsgType_UserNotification_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_UserResponse", VALUEFUNC(MsgType_UserResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DontKnowTrade", VALUEFUNC(MsgType_DontKnowTrade_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReportAck", VALUEFUNC(MsgType_TradeCaptureReportAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ApplicationMessageRequest", VALUEFUNC(MsgType_ApplicationMessageRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MultilegOrderCancelReplace", VALUEFUNC(MsgType_MultilegOrderCancelReplace_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderCancelReject", VALUEFUNC(MsgType_OrderCancelReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ExecutionReport", VALUEFUNC(MsgType_ExecutionReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteStatusReport", VALUEFUNC(MsgType_QuoteStatusReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ResendRequest", VALUEFUNC(MsgType_ResendRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Quote", VALUEFUNC(MsgType_Quote_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SettlementInstructionRequest", VALUEFUNC(MsgType_SettlementInstructionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityListUpdateReport", VALUEFUNC(MsgType_SecurityListUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationInstructionAlert", VALUEFUNC(MsgType_AllocationInstructionAlert_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReportRequestAck", VALUEFUNC(MsgType_TradeCaptureReportRequestAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationInstruction", VALUEFUNC(MsgType_AllocationInstruction_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Allocation", VALUEFUNC(MsgType_Allocation_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ApplicationMessageReport", VALUEFUNC(MsgType_ApplicationMessageReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RegistrationInstructions", VALUEFUNC(MsgType_RegistrationInstructions_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityDefinition", VALUEFUNC(MsgType_SecurityDefinition_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityDefinitionRequest", VALUEFUNC(MsgType_SecurityDefinitionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityStatus", VALUEFUNC(MsgType_SecurityStatus_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DerivativeSecurityList", VALUEFUNC(MsgType_DerivativeSecurityList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_NetworkCounterpartySystemStatusRequest", VALUEFUNC(MsgType_NetworkCounterpartySystemStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDefinitionRequest", VALUEFUNC(MsgType_MarketDefinitionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_Reject", VALUEFUNC(MsgType_Reject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_DerivativeSecurityListUpdateReport", VALUEFUNC(MsgType_DerivativeSecurityListUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteRequestReject", VALUEFUNC(MsgType_QuoteRequestReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassStatusRequest", VALUEFUNC(MsgType_OrderMassStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_ApplicationMessageRequestAck", VALUEFUNC(MsgType_ApplicationMessageRequestAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SecurityStatusRequest", VALUEFUNC(MsgType_SecurityStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationACK", VALUEFUNC(MsgType_AllocationACK_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDefinitionUpdateReport", VALUEFUNC(MsgType_MarketDefinitionUpdateReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CrossOrderCancelReplaceRequest", VALUEFUNC(MsgType_CrossOrderCancelReplaceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassCancelReport", VALUEFUNC(MsgType_OrderMassCancelReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AssignmentReport", VALUEFUNC(MsgType_AssignmentReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_BidResponse", VALUEFUNC(MsgType_BidResponse_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RequestForPositions", VALUEFUNC(MsgType_RequestForPositions_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SettlementObligationReport", VALUEFUNC(MsgType_SettlementObligationReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassCancelRequest", VALUEFUNC(MsgType_OrderMassCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradingSessionList", VALUEFUNC(MsgType_TradingSessionList_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderStatusRequest", VALUEFUNC(MsgType_OrderStatusRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralAssignment", VALUEFUNC(MsgType_CollateralAssignment_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_StreamAssignmentReport", VALUEFUNC(MsgType_StreamAssignmentReport_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderMassActionRequest", VALUEFUNC(MsgType_OrderMassActionRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationAck", VALUEFUNC(MsgType_AllocationAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_QuoteRequest", VALUEFUNC(MsgType_QuoteRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_CollateralInquiryAck", VALUEFUNC(MsgType_CollateralInquiryAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataSnapshotFullRefresh", VALUEFUNC(MsgType_MarketDataSnapshotFullRefresh_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_SettlementInstructions", VALUEFUNC(MsgType_SettlementInstructions_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderCancelReplaceRequest", VALUEFUNC(MsgType_OrderCancelReplaceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_TradeCaptureReportRequest", VALUEFUNC(MsgType_TradeCaptureReportRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_RFQRequest", VALUEFUNC(MsgType_RFQRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_OrderCancelRequest", VALUEFUNC(MsgType_OrderCancelRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MultilegOrderCancelReplaceRequest", VALUEFUNC(MsgType_MultilegOrderCancelReplaceRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_AllocationInstructionAck", VALUEFUNC(MsgType_AllocationInstructionAck_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataRequest", VALUEFUNC(MsgType_MarketDataRequest_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgType_MarketDataRequestReject", VALUEFUNC(MsgType_MarketDataRequestReject_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_SINGLE", VALUEFUNC(MultiLegReportingType_SINGLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_MULTILEG", VALUEFUNC(MultiLegReportingType_MULTILEG_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_SINGLE_SECURITY", VALUEFUNC(MultiLegReportingType_SINGLE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_MULTI_LEG_SECURITY", VALUEFUNC(MultiLegReportingType_MULTI_LEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_INDIVLEG", VALUEFUNC(MultiLegReportingType_INDIVLEG_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY", VALUEFUNC(MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY", VALUEFUNC(MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_EXCHANGE_SYMBOL", VALUEFUNC(IDSource_EXCHANGE_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_RIC_CODE", VALUEFUNC(IDSource_RIC_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_ISO_CURRENCY_CODE", VALUEFUNC(IDSource_ISO_CURRENCY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_ISIN_NUMBER", VALUEFUNC(IDSource_ISIN_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_SEDOL", VALUEFUNC(IDSource_SEDOL_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_ISO_COUNTRY_CODE", VALUEFUNC(IDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_CONSOLIDATED_TAPE_ASSOCIATION", VALUEFUNC(IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_QUIK", VALUEFUNC(IDSource_QUIK_get), 0);
  rb_define_singleton_method(mQuickfix, "IDSource_CUSIP", VALUEFUNC(IDSource_CUSIP_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_NEW", VALUEFUNC(OrdStatus_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_CALCULATED", VALUEFUNC(OrdStatus_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDINGNEW", VALUEFUNC(OrdStatus_PENDINGNEW_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_CANCEL", VALUEFUNC(OrdStatus_PENDING_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PARTIAL", VALUEFUNC(OrdStatus_PARTIAL_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_CANCEL_REPLACE", VALUEFUNC(OrdStatus_PENDING_CANCEL_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_NEW", VALUEFUNC(OrdStatus_PENDING_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_STOPPED", VALUEFUNC(OrdStatus_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_FILLED", VALUEFUNC(OrdStatus_FILLED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDING_REPLACE", VALUEFUNC(OrdStatus_PENDING_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_CANCELED", VALUEFUNC(OrdStatus_CANCELED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_ACCEPTED_FOR_BIDDING", VALUEFUNC(OrdStatus_ACCEPTED_FOR_BIDDING_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_SUSPENDED", VALUEFUNC(OrdStatus_SUSPENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_DONE", VALUEFUNC(OrdStatus_DONE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_REJECTED", VALUEFUNC(OrdStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PARTIALLY_FILLED", VALUEFUNC(OrdStatus_PARTIALLY_FILLED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_EXPIRED", VALUEFUNC(OrdStatus_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_REPLACED", VALUEFUNC(OrdStatus_REPLACED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_DONE_FOR_DAY", VALUEFUNC(OrdStatus_DONE_FOR_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_ACCEPTBIDDING", VALUEFUNC(OrdStatus_ACCEPTBIDDING_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdStatus_PENDINGREP", VALUEFUNC(OrdStatus_PENDINGREP_get), 0);
  rb_define_singleton_method(mQuickfix, "CustomerOrFirm_FIRM", VALUEFUNC(CustomerOrFirm_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "CustomerOrFirm_CUSTOMER", VALUEFUNC(CustomerOrFirm_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_DELTA_MINUS", VALUEFUNC(AdjustmentType_DELTA_MINUS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_DELTAPLUS", VALUEFUNC(AdjustmentType_DELTAPLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_DELTA_PLUS", VALUEFUNC(AdjustmentType_DELTA_PLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_DELTAMINUS", VALUEFUNC(AdjustmentType_DELTAMINUS_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_FINAL", VALUEFUNC(AdjustmentType_FINAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION", VALUEFUNC(AdjustmentType_PROCESSREQUESTASMARGINDISPOSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION", VALUEFUNC(AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "AsOfIndicator_TRUE", VALUEFUNC(AsOfIndicator_TRUE_get), 0);
  rb_define_singleton_method(mQuickfix, "AsOfIndicator_FALSE", VALUEFUNC(AsOfIndicator_FALSE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_MARKET", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS", VALUEFUNC(MassActionScope_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_CFICODE", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_SECURITY", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_CANCEL_FOR_SECURITY_ISSUER", VALUEFUNC(MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_PRODUCT", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "VenueType_PIT", VALUEFUNC(VenueType_PIT_get), 0);
  rb_define_singleton_method(mQuickfix, "VenueType_EX_PIT", VALUEFUNC(VenueType_EX_PIT_get), 0);
  rb_define_singleton_method(mQuickfix, "VenueType_ELECTRONIC", VALUEFUNC(VenueType_ELECTRONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionType_CANCEL_ORDERS", VALUEFUNC(MassActionType_CANCEL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionType_RELEASE_ORDERS_FROM_SUSPENSION", VALUEFUNC(MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionType_SUSPEND_ORDERS", VALUEFUNC(MassActionType_SUSPEND_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintResult_SUCCESSFULCOMPLETION", VALUEFUNC(PosMaintResult_SUCCESSFULCOMPLETION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintResult_SUCCESSFUL_COMPLETION", VALUEFUNC(PosMaintResult_SUCCESSFUL_COMPLETION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintResult_OTHER", VALUEFUNC(PosMaintResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintResult_REJECTED", VALUEFUNC(PosMaintResult_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIShares_MEDIUM", VALUEFUNC(IOIShares_MEDIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIShares_LARGE", VALUEFUNC(IOIShares_LARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIShares_SMALL", VALUEFUNC(IOIShares_SMALL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_PRICE", VALUEFUNC(PegOffsetType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_BASISPOINTS", VALUEFUNC(PegOffsetType_BASISPOINTS_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_PRICE_TIER", VALUEFUNC(PegOffsetType_PRICE_TIER_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_TICKS", VALUEFUNC(PegOffsetType_TICKS_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_PRICETIERLEVEL", VALUEFUNC(PegOffsetType_PRICETIERLEVEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegOffsetType_BASIS_POINTS", VALUEFUNC(PegOffsetType_BASIS_POINTS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALIDSECURITY", VALUEFUNC(MassCancelRejectReason_INVALIDSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED", VALUEFUNC(MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALIDPRODUCT", VALUEFUNC(MassCancelRejectReason_INVALIDPRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALIDUNDERLYING", VALUEFUNC(MassCancelRejectReason_INVALIDUNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_OTHER", VALUEFUNC(MassCancelRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALIDCFICODE", VALUEFUNC(MassCancelRejectReason_INVALIDCFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALIDSECURITYTYPE", VALUEFUNC(MassCancelRejectReason_INVALIDSECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING", VALUEFUNC(MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_INVALIDTRDSESSION", VALUEFUNC(MassCancelRejectReason_INVALIDTRDSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRejectReason_MASSCXLNOTSUPPORTED", VALUEFUNC(MassCancelRejectReason_MASSCXLNOTSUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ResponseTransportType_OUTOFBAND", VALUEFUNC(ResponseTransportType_OUTOFBAND_get), 0);
  rb_define_singleton_method(mQuickfix, "ResponseTransportType_INBAND", VALUEFUNC(ResponseTransportType_INBAND_get), 0);
  rb_define_singleton_method(mQuickfix, "ResponseTransportType_OUT_OF_BAND", VALUEFUNC(ResponseTransportType_OUT_OF_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID", VALUEFUNC(TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID", VALUEFUNC(TradSesStatusRejReason_UNKNOWNTRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesStatusRejReason_OTHER", VALUEFUNC(TradSesStatusRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_EXECUTION_TIME", VALUEFUNC(TrdRegTimestampType_EXECUTION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_BROKEREXECUTION", VALUEFUNC(TrdRegTimestampType_BROKEREXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_BROKERRECEIPT", VALUEFUNC(TrdRegTimestampType_BROKERRECEIPT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_TIMEIN", VALUEFUNC(TrdRegTimestampType_TIMEIN_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_TIME_IN", VALUEFUNC(TrdRegTimestampType_TIME_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_TIMEOUT", VALUEFUNC(TrdRegTimestampType_TIMEOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_SUBMISSION_TO_CLEARING", VALUEFUNC(TrdRegTimestampType_SUBMISSION_TO_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_BROKER_RECEIPT", VALUEFUNC(TrdRegTimestampType_BROKER_RECEIPT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_DESK_RECEIPT", VALUEFUNC(TrdRegTimestampType_DESK_RECEIPT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_EXECUTIONTIME", VALUEFUNC(TrdRegTimestampType_EXECUTIONTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_BROKER_EXECUTION", VALUEFUNC(TrdRegTimestampType_BROKER_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRegTimestampType_TIME_OUT", VALUEFUNC(TrdRegTimestampType_TIME_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX50SP1", VALUEFUNC(ApplVerID_FIX50SP1_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX27", VALUEFUNC(ApplVerID_FIX27_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX50SP2", VALUEFUNC(ApplVerID_FIX50SP2_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX50", VALUEFUNC(ApplVerID_FIX50_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX40", VALUEFUNC(ApplVerID_FIX40_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX41", VALUEFUNC(ApplVerID_FIX41_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX30", VALUEFUNC(ApplVerID_FIX30_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX42", VALUEFUNC(ApplVerID_FIX42_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX43", VALUEFUNC(ApplVerID_FIX43_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplVerID_FIX44", VALUEFUNC(ApplVerID_FIX44_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_MANUAL_ORDER_BEST_EXECUTION", VALUEFUNC(HandlInst_MANUAL_ORDER_BEST_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_AUTOEXECPUB", VALUEFUNC(HandlInst_AUTOEXECPUB_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION", VALUEFUNC(HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_AUTOEXECPRIV", VALUEFUNC(HandlInst_AUTOEXECPRIV_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK", VALUEFUNC(HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_get), 0);
  rb_define_singleton_method(mQuickfix, "HandlInst_MANUAL", VALUEFUNC(HandlInst_MANUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_POST_TRADING", VALUEFUNC(TradingSessionSubID_POST_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_INTRADAY_AUCTION", VALUEFUNC(TradingSessionSubID_INTRADAY_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_PRE_TRADING", VALUEFUNC(TradingSessionSubID_PRE_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_QUIESCENT", VALUEFUNC(TradingSessionSubID_QUIESCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_3", VALUEFUNC(TradingSessionSubID_3_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_OPENING_OR_OPENING_AUCTION", VALUEFUNC(TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION", VALUEFUNC(TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SWAP_VALUE_FACTOR", VALUEFUNC(MDEntryType_SWAP_VALUE_FACTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OPEN_INTEREST", VALUEFUNC(MDEntryType_OPEN_INTEREST_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_COMPOSITE_UNDERLYING_PRICE", VALUEFUNC(MDEntryType_COMPOSITE_UNDERLYING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SESSION_HIGH_BID", VALUEFUNC(MDEntryType_SESSION_HIGH_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_INDEXVALUE", VALUEFUNC(MDEntryType_INDEXVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OPENINTEREST", VALUEFUNC(MDEntryType_OPENINTEREST_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CLOSING_PRICE", VALUEFUNC(MDEntryType_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_PRIOR_SETTLE_PRICE", VALUEFUNC(MDEntryType_PRIOR_SETTLE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADING_SESSION_VWAP_PRICE", VALUEFUNC(MDEntryType_TRADING_SESSION_VWAP_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADING_SESSION_LOW_PRICE", VALUEFUNC(MDEntryType_TRADING_SESSION_LOW_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SETTLE_HIGH_PRICE", VALUEFUNC(MDEntryType_SETTLE_HIGH_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_IMBALANCE", VALUEFUNC(MDEntryType_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_FIXING_PRICE", VALUEFUNC(MDEntryType_FIXING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CASH_RATE", VALUEFUNC(MDEntryType_CASH_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CLOSING", VALUEFUNC(MDEntryType_CLOSING_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OPENING", VALUEFUNC(MDEntryType_OPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OPENING_PRICE", VALUEFUNC(MDEntryType_OPENING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADINGHIGH", VALUEFUNC(MDEntryType_TRADINGHIGH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADEVOLUME", VALUEFUNC(MDEntryType_TRADEVOLUME_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADE", VALUEFUNC(MDEntryType_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS", VALUEFUNC(MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SIMULATED_SELL_PRICE", VALUEFUNC(MDEntryType_SIMULATED_SELL_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_EMPTY_BOOK", VALUEFUNC(MDEntryType_EMPTY_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_AUCTION_CLEARING_PRICE", VALUEFUNC(MDEntryType_AUCTION_CLEARING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_BID", VALUEFUNC(MDEntryType_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_RECOVERY_RATE_FOR_SHORT", VALUEFUNC(MDEntryType_RECOVERY_RATE_FOR_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SIMULATED_BUY_PRICE", VALUEFUNC(MDEntryType_SIMULATED_BUY_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_EARLY_PRICES", VALUEFUNC(MDEntryType_EARLY_PRICES_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADINGLOW", VALUEFUNC(MDEntryType_TRADINGLOW_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADING_SESSION_HIGH_PRICE", VALUEFUNC(MDEntryType_TRADING_SESSION_HIGH_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_INDEX_VALUE", VALUEFUNC(MDEntryType_INDEX_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_RECOVERY_RATE_FOR_LONG", VALUEFUNC(MDEntryType_RECOVERY_RATE_FOR_LONG_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS", VALUEFUNC(MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_MID_PRICE", VALUEFUNC(MDEntryType_MID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SETTLEMENT", VALUEFUNC(MDEntryType_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_RECOVERY_RATE", VALUEFUNC(MDEntryType_RECOVERY_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS", VALUEFUNC(MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS", VALUEFUNC(MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADE_VOLUME", VALUEFUNC(MDEntryType_TRADE_VOLUME_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_MARGIN_RATE", VALUEFUNC(MDEntryType_MARGIN_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SETTLE_LOW_PRICE", VALUEFUNC(MDEntryType_SETTLE_LOW_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SESSION_LOW_OFFER", VALUEFUNC(MDEntryType_SESSION_LOW_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_TRADINGVWAP", VALUEFUNC(MDEntryType_TRADINGVWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_SETTLEMENT_PRICE", VALUEFUNC(MDEntryType_SETTLEMENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDEntryType_OFFER", VALUEFUNC(MDEntryType_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "PegMoveType_FLOATING", VALUEFUNC(PegMoveType_FLOATING_get), 0);
  rb_define_singleton_method(mQuickfix, "PegMoveType_FIXED", VALUEFUNC(PegMoveType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_NOAVERAGEPRICING", VALUEFUNC(AvgPxIndicator_NOAVERAGEPRICING_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_NO_AVERAGE_PRICING", VALUEFUNC(AvgPxIndicator_NO_AVERAGE_PRICING_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP", VALUEFUNC(AvgPxIndicator_LASTTRADEAVERAGEPRICEGROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID", VALUEFUNC(AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_TRADEAVERAGEPRICEGROUP", VALUEFUNC(AvgPxIndicator_TRADEAVERAGEPRICEGROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID", VALUEFUNC(AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_WAIVER_AGREEMENT", VALUEFUNC(CancellationRights_NO_WAIVER_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_M", VALUEFUNC(CancellationRights_NO_M_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_N", VALUEFUNC(CancellationRights_NO_N_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NOINSTIT", VALUEFUNC(CancellationRights_NOINSTIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_INSTITUTIONAL", VALUEFUNC(CancellationRights_NO_INSTITUTIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_YES", VALUEFUNC(CancellationRights_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_O", VALUEFUNC(CancellationRights_NO_O_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NOEXECONLY", VALUEFUNC(CancellationRights_NOEXECONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NO_EXECUTION_ONLY", VALUEFUNC(CancellationRights_NO_EXECUTION_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "CancellationRights_NOWAIVER", VALUEFUNC(CancellationRights_NOWAIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATIONPRICEADJAMT", VALUEFUNC(ExecPriceType_CREATIONPRICEADJAMT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE", VALUEFUNC(ExecPriceType_CREATION_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATIONPRICE", VALUEFUNC(ExecPriceType_CREATIONPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_SINGLEPRICE", VALUEFUNC(ExecPriceType_SINGLEPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT", VALUEFUNC(ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFERPRICE", VALUEFUNC(ExecPriceType_OFFERPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_BIDPRICE", VALUEFUNC(ExecPriceType_BIDPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT", VALUEFUNC(ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATIONPRICEADJPCT", VALUEFUNC(ExecPriceType_CREATIONPRICEADJPCT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT", VALUEFUNC(ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFERPRICEMINUSADJAMT", VALUEFUNC(ExecPriceType_OFFERPRICEMINUSADJAMT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT", VALUEFUNC(ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT", VALUEFUNC(ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFERPRICEMINUSADJPCT", VALUEFUNC(ExecPriceType_OFFERPRICEMINUSADJPCT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_BID_PRICE", VALUEFUNC(ExecPriceType_BID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_SINGLE_PRICE", VALUEFUNC(ExecPriceType_SINGLE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT", VALUEFUNC(ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecPriceType_OFFER_PRICE", VALUEFUNC(ExecPriceType_OFFER_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_PHONEFORINSTRUCTIONS", VALUEFUNC(AllocSettlInstType_PHONEFORINSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_SSIDBIDSPROVIDED", VALUEFUNC(AllocSettlInstType_SSIDBIDSPROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_FULLDETAILSPROVIDED", VALUEFUNC(AllocSettlInstType_FULLDETAILSPROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_USEDEFAULTINSTRUCTIONS", VALUEFUNC(AllocSettlInstType_USEDEFAULTINSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_SSI_DB_IDS_PROVIDED", VALUEFUNC(AllocSettlInstType_SSI_DB_IDS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_PHONE_FOR_INSTRUCTIONS", VALUEFUNC(AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED", VALUEFUNC(AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_FULL_DETAILS_PROVIDED", VALUEFUNC(AllocSettlInstType_FULL_DETAILS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS", VALUEFUNC(AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED", VALUEFUNC(AllocSettlInstType_DERIVEFROMPARAMETERSPROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_AVERAGE_PRICE", VALUEFUNC(StatsType_AVERAGE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_HIGH", VALUEFUNC(StatsType_HIGH_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_EXCHANGE_LAST", VALUEFUNC(StatsType_EXCHANGE_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "StatsType_TURNOVER", VALUEFUNC(StatsType_TURNOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMode_SIMULATED", VALUEFUNC(TradSesMode_SIMULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMode_PRODUCTION", VALUEFUNC(TradSesMode_PRODUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMode_TESTING", VALUEFUNC(TradSesMode_TESTING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_INSTITUTIONS_INSTRUCTIONS", VALUEFUNC(SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_BROKERS_INSTRUCTIONS", VALUEFUNC(SettlInstSource_BROKERS_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_INVESTORCIV", VALUEFUNC(SettlInstSource_INVESTORCIV_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_INVESTOR", VALUEFUNC(SettlInstSource_INVESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_INSTINSTR", VALUEFUNC(SettlInstSource_INSTINSTR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstSource_BROKERINSTR", VALUEFUNC(SettlInstSource_BROKERINSTR_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_DIFFERENCE", VALUEFUNC(ExpType_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_FINAL_WILL_BE_EXERCISED", VALUEFUNC(ExpType_FINAL_WILL_BE_EXERCISED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_NON_AUTO_EXERCISE", VALUEFUNC(ExpType_NON_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_CONTRARY_INTENTION", VALUEFUNC(ExpType_CONTRARY_INTENTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpType_AUTO_EXERCISE", VALUEFUNC(ExpType_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_REPLACE", VALUEFUNC(SettlInstTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_NEW", VALUEFUNC(SettlInstTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_RESTATE", VALUEFUNC(SettlInstTransType_RESTATE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstTransType_CANCEL", VALUEFUNC(SettlInstTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED", VALUEFUNC(TradeRequestResult_TRADEREQUESTTYPENOTSUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT", VALUEFUNC(TradeRequestResult_INVALIDORUNKNOWNINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_DESTINATION_REQUESTED", VALUEFUNC(TradeRequestResult_INVALID_DESTINATION_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST", VALUEFUNC(TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED", VALUEFUNC(TradeRequestResult_INVALIDTRANSPORTTYPEREQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALIDPARTIES", VALUEFUNC(TradeRequestResult_INVALIDPARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALIDDESTINATIONREQUESTED", VALUEFUNC(TradeRequestResult_INVALIDDESTINATIONREQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_SUCCESSFUL", VALUEFUNC(TradeRequestResult_SUCCESSFUL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT", VALUEFUNC(TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_OTHER", VALUEFUNC(TradeRequestResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED", VALUEFUNC(TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_PARTIES", VALUEFUNC(TradeRequestResult_INVALID_PARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST", VALUEFUNC(TradeRequestResult_UNAUTHORIZEDFORTRADECAPTUREREPORTREQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_NOT_AUTHORIZED", VALUEFUNC(TradeRequestResult_NOT_AUTHORIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED", VALUEFUNC(TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED", VALUEFUNC(TradeRequestResult_INVALIDTYPEOFTRADEREQUESTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED", VALUEFUNC(TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TestMessageIndicator_NO", VALUEFUNC(TestMessageIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "TestMessageIndicator_YES", VALUEFUNC(TestMessageIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE", VALUEFUNC(ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_EXPIREONTRADINGSESSIONOPEN", VALUEFUNC(ExpirationCycle_EXPIREONTRADINGSESSIONOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE", VALUEFUNC(ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN", VALUEFUNC(ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE", VALUEFUNC(ExpirationCycle_EXPIREONTRADINGSESSIONCLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_ORIGINALDETAILSINCORRECT", VALUEFUNC(AllocCancReplaceReason_ORIGINALDETAILSINCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS", VALUEFUNC(AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_OTHER", VALUEFUNC(AllocCancReplaceReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT", VALUEFUNC(AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS", VALUEFUNC(AllocCancReplaceReason_CHANGEINUNDERLYINGORDERDETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_DUPLICATE_CLORDID", VALUEFUNC(CxlRejReason_DUPLICATE_CLORDID_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_UNABLETOPROCESS", VALUEFUNC(CxlRejReason_UNABLETOPROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE", VALUEFUNC(CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_DUPCLORDID", VALUEFUNC(CxlRejReason_DUPCLORDID_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_DUPLICATE_CLORDID_RECEIVED", VALUEFUNC(CxlRejReason_DUPLICATE_CLORDID_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_UNKNOWN_ORDER", VALUEFUNC(CxlRejReason_UNKNOWN_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_TOO_LATE_TO_CANCEL", VALUEFUNC(CxlRejReason_TOO_LATE_TO_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_TOOLATE", VALUEFUNC(CxlRejReason_TOOLATE_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_ORIGORDMODTIME", VALUEFUNC(CxlRejReason_ORIGORDMODTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_INVALID_PRICE_INCREMENT", VALUEFUNC(CxlRejReason_INVALID_PRICE_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_BROKEROPT", VALUEFUNC(CxlRejReason_BROKEROPT_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_ALREADYPENDINGCXL", VALUEFUNC(CxlRejReason_ALREADYPENDINGCXL_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_OTHER", VALUEFUNC(CxlRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_BROKER", VALUEFUNC(CxlRejReason_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_BROKER_OPTION", VALUEFUNC(CxlRejReason_BROKER_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST", VALUEFUNC(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(CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND", VALUEFUNC(CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_ORIGORDMODTIMEMISMATCH", VALUEFUNC(CxlRejReason_ORIGORDMODTIMEMISMATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER", VALUEFUNC(CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejReason_UNKNOWN", VALUEFUNC(CxlRejReason_UNKNOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_SPECIFIED_MARKET_PARTICIPANTS", VALUEFUNC(RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_ALL_MARKET_MAKERS", VALUEFUNC(RespondentType_ALL_MARKET_MAKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_ALL_MARKET_PARTICIPANTS", VALUEFUNC(RespondentType_ALL_MARKET_PARTICIPANTS_get), 0);
  rb_define_singleton_method(mQuickfix, "RespondentType_PRIMARY_MARKET_MAKER", VALUEFUNC(RespondentType_PRIMARY_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_NO_MATCHING_ORDER", VALUEFUNC(DKReason_NO_MATCHING_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_UNKNOWNSYMBOL", VALUEFUNC(DKReason_UNKNOWNSYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_PRICE_EXCEEDS_LIMIT", VALUEFUNC(DKReason_PRICE_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_QUANTITYEXCEEDSORDER", VALUEFUNC(DKReason_QUANTITYEXCEEDSORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_QUANTITY_EXCEEDS_ORDER", VALUEFUNC(DKReason_QUANTITY_EXCEEDS_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_UNKNOWN_SYMBOL", VALUEFUNC(DKReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_OTHER", VALUEFUNC(DKReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_WRONGSIDE", VALUEFUNC(DKReason_WRONGSIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_CALCULATIONDIFFERENCE", VALUEFUNC(DKReason_CALCULATIONDIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_PRICEEXCEEDSLIMIT", VALUEFUNC(DKReason_PRICEEXCEEDSLIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_WRONG_SIDE", VALUEFUNC(DKReason_WRONG_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_CALCULATION_DIFFERENCE", VALUEFUNC(DKReason_CALCULATION_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "DKReason_NOMATCH", VALUEFUNC(DKReason_NOMATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_DEFAULT", VALUEFUNC(PositionEffect_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_CLOSE", VALUEFUNC(PositionEffect_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN", VALUEFUNC(PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_OPEN", VALUEFUNC(PositionEffect_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_FIFO", VALUEFUNC(PositionEffect_FIFO_get), 0);
  rb_define_singleton_method(mQuickfix, "PositionEffect_ROLLED", VALUEFUNC(PositionEffect_ROLLED_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerAction_ACTIVATE", VALUEFUNC(TriggerAction_ACTIVATE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerAction_MODIFY", VALUEFUNC(TriggerAction_MODIFY_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerAction_CANCEL", VALUEFUNC(TriggerAction_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_BILATERALNETTINGONLY", VALUEFUNC(ClearingInstruction_BILATERALNETTINGONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_SPECIALTRADE", VALUEFUNC(ClearingInstruction_SPECIALTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EXCLUDE_FROM_ALL_NETTING", VALUEFUNC(ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_AUTOMATIC_POSTING_MODE", VALUEFUNC(ClearingInstruction_AUTOMATIC_POSTING_MODE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EXCLEARING", VALUEFUNC(ClearingInstruction_EXCLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_MULTILATERAL_NETTING", VALUEFUNC(ClearingInstruction_MULTILATERAL_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY", VALUEFUNC(ClearingInstruction_CLEARAGAINSTCENTRALCOUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY", VALUEFUNC(ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_AUTOMATIC_GIVE_UP_MODE", VALUEFUNC(ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_CUSTOMER_TRADE", VALUEFUNC(ClearingInstruction_CUSTOMER_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED", VALUEFUNC(ClearingInstruction_AUTOMATICPOSTINGMODETRADEPOSTINGTOTHEPOSITIONACCOUNTNUMBERSPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EX_CLEARING", VALUEFUNC(ClearingInstruction_EX_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR", VALUEFUNC(ClearingInstruction_QUALIFIEDSERVICEREPRESENTATIVEQSR_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_MULTILATERALNETTING", VALUEFUNC(ClearingInstruction_MULTILATERALNETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_PROCESSNORMALLY", VALUEFUNC(ClearingInstruction_PROCESSNORMALLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EXCLUDEFROMALLNETTING", VALUEFUNC(ClearingInstruction_EXCLUDEFROMALLNETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_SELFCLEARING", VALUEFUNC(ClearingInstruction_SELFCLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY", VALUEFUNC(ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_BILATERAL_NETTING_ONLY", VALUEFUNC(ClearingInstruction_BILATERAL_NETTING_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY", VALUEFUNC(ClearingInstruction_EXCLUDEFROMCENTRALCOUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP", VALUEFUNC(ClearingInstruction_MANUALMODEPREPOSTINGANDORPREGIVEUP_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_CUSTOMERTRADE", VALUEFUNC(ClearingInstruction_CUSTOMERTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_PROCESS_NORMALLY", VALUEFUNC(ClearingInstruction_PROCESS_NORMALLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_SPECIAL_TRADE", VALUEFUNC(ClearingInstruction_SPECIAL_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_MANUAL_MODE", VALUEFUNC(ClearingInstruction_MANUAL_MODE_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR", VALUEFUNC(ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED", VALUEFUNC(ClearingInstruction_AUTOMATICGIVEUPMODETRADEGIVEUPTOTHEGIVEUPDESTINATIONNUMBERSPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "ClearingInstruction_SELF_CLEARING", VALUEFUNC(ClearingInstruction_SELF_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_SESSION_OPEN", VALUEFUNC(OpenCloseSettlFlag_SESSION_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_EXPECTED_ENTRY", VALUEFUNC(OpenCloseSettlFlag_EXPECTED_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_THEORETICALPRICE", VALUEFUNC(OpenCloseSettlFlag_THEORETICALPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY", VALUEFUNC(OpenCloseSettlFlag_ENTRYFROMPREVBUSINESSDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_DAILY_OPEN", VALUEFUNC(OpenCloseSettlFlag_DAILY_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_DAILYOPEN", VALUEFUNC(OpenCloseSettlFlag_DAILYOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE", VALUEFUNC(OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY", VALUEFUNC(OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY", VALUEFUNC(OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_DELIVERYSETTLEMENT", VALUEFUNC(OpenCloseSettlFlag_DELIVERYSETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_SESSIONOPEN", VALUEFUNC(OpenCloseSettlFlag_SESSIONOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettlFlag_EXPECTEDENTRY", VALUEFUNC(OpenCloseSettlFlag_EXPECTEDENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionMoveType_FLOATING", VALUEFUNC(DiscretionMoveType_FLOATING_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionMoveType_FIXED", VALUEFUNC(DiscretionMoveType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateType_INCREMENTAL_REFRESH", VALUEFUNC(MDUpdateType_INCREMENTAL_REFRESH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateType_FULL_REFRESH", VALUEFUNC(MDUpdateType_FULL_REFRESH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateType_FULL", VALUEFUNC(MDUpdateType_FULL_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateType_INCREMENTAL", VALUEFUNC(MDUpdateType_INCREMENTAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_MINUS_TICK", VALUEFUNC(TickDirection_MINUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_ZERO_PLUS_TICK", VALUEFUNC(TickDirection_ZERO_PLUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_ZERO_MINUS_TICK", VALUEFUNC(TickDirection_ZERO_MINUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_PLUS_TICK", VALUEFUNC(TickDirection_PLUS_TICK_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_PLUS", VALUEFUNC(TickDirection_PLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_ZEROPLUS", VALUEFUNC(TickDirection_ZEROPLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_MINUS", VALUEFUNC(TickDirection_MINUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TickDirection_ZEROMINUS", VALUEFUNC(TickDirection_ZEROMINUS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MARK_TO_MARKET_YIELD", VALUEFUNC(YieldType_MARK_TO_MARKET_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER", VALUEFUNC(YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_MATURITY", VALUEFUNC(YieldType_YIELD_TO_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTOTENDERDATE", VALUEFUNC(YieldType_YIELDTOTENDERDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PREVIOUS_CLOSE_YIELD", VALUEFUNC(YieldType_PREVIOUS_CLOSE_YIELD_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(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_YIELDTOSHORTESTAVERAGELIFE", VALUEFUNC(YieldType_YIELDTOSHORTESTAVERAGELIFE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_AT_ISSUE", VALUEFUNC(YieldType_YIELD_AT_ISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_REFUND", VALUEFUNC(YieldType_YIELD_TO_NEXT_REFUND_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDATISSUE", VALUEFUNC(YieldType_YIELDATISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSINGYIELD", VALUEFUNC(YieldType_CLOSINGYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_GVNTEQUIVALENTYIELD", VALUEFUNC(YieldType_GVNTEQUIVALENTYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_ANNUALYIELD", VALUEFUNC(YieldType_ANNUALYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_AFTER_TAX_YIELD", VALUEFUNC(YieldType_AFTER_TAX_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_GVNT_EQUIVALENT_YIELD", VALUEFUNC(YieldType_GVNT_EQUIVALENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDCHANGESINCECLOSE", VALUEFUNC(YieldType_YIELDCHANGESINCECLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTOMATURITY", VALUEFUNC(YieldType_YIELDTOMATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE", VALUEFUNC(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(YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_SEMI", VALUEFUNC(YieldType_SEMI_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(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_CLOSING_YIELD_MOST_RECENT_YEAR", VALUEFUNC(YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_CALL", VALUEFUNC(YieldType_YIELD_TO_NEXT_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_CHANGE_SINCE_CLOSE", VALUEFUNC(YieldType_YIELD_CHANGE_SINCE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PROCEEDS_YIELD", VALUEFUNC(YieldType_PROCEEDS_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE", VALUEFUNC(YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_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(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(YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CURRENT_YIELD", VALUEFUNC(YieldType_CURRENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_SIMPLEYIELD", VALUEFUNC(YieldType_SIMPLEYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TRUEGROSSYIELD", VALUEFUNC(YieldType_TRUEGROSSYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_COMPOUND_YIELD", VALUEFUNC(YieldType_COMPOUND_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSINGYIELDMOSTRECENTYEAR", VALUEFUNC(YieldType_CLOSINGYIELDMOSTRECENTYEAR_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(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_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER", VALUEFUNC(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(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(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(YieldType_YIELD_TO_AVG_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_TENDER_DATE", VALUEFUNC(YieldType_YIELD_TO_TENDER_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PROCEEDSYIELD", VALUEFUNC(YieldType_PROCEEDSYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO", VALUEFUNC(YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_ANNUAL_YIELD", VALUEFUNC(YieldType_ANNUAL_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_WORST", VALUEFUNC(YieldType_YIELD_TO_WORST_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_BOOK_YIELD", VALUEFUNC(YieldType_BOOK_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_NEXT_PUT", VALUEFUNC(YieldType_YIELD_TO_NEXT_PUT_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(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(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_OPENAVERAGEYIELD", VALUEFUNC(YieldType_OPENAVERAGEYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TRUE_YIELD", VALUEFUNC(YieldType_TRUE_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TAX_EQUIVALENT_YIELD", VALUEFUNC(YieldType_TAX_EQUIVALENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TRUE_GROSS_YIELD", VALUEFUNC(YieldType_TRUE_GROSS_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_INVERSE_FLOATER_BOND_YIELD", VALUEFUNC(YieldType_INVERSE_FLOATER_BOND_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(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(YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_AFTERTAXYIELD", VALUEFUNC(YieldType_AFTERTAXYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE", VALUEFUNC(YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTOWORSTCONVENTION", VALUEFUNC(YieldType_YIELDTOWORSTCONVENTION_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(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_COMPOUNDYIELD", VALUEFUNC(YieldType_COMPOUNDYIELD_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(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_YIELD_TO_LONGEST_AVERAGE", VALUEFUNC(YieldType_YIELD_TO_LONGEST_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_PREVIOUSCLOSEYIELD", VALUEFUNC(YieldType_PREVIOUSCLOSEYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSINGYIELDMOSTRECENTMONTH", VALUEFUNC(YieldType_CLOSINGYIELDMOSTRECENTMONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD_MOST_RECENT_MONTH", VALUEFUNC(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(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(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(YieldType_YIELD_TO_SHORTEST_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_TAXEQUIVALENTYIELD", VALUEFUNC(YieldType_TAXEQUIVALENTYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MOSTRECENTCLOSINGYIELD", VALUEFUNC(YieldType_MOSTRECENTCLOSINGYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MARKTOMARKETYIELD", VALUEFUNC(YieldType_MARKTOMARKETYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CURRENTYIELD", VALUEFUNC(YieldType_CURRENTYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_OPEN_AVERAGE_YIELD", VALUEFUNC(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(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_YIELD_WITH_INFLATION_ASSUMPTION", VALUEFUNC(YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTONEXTREFUNDSINKING", VALUEFUNC(YieldType_YIELDTONEXTREFUNDSINKING_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(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_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(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(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_SIMPLE_YIELD", VALUEFUNC(YieldType_SIMPLE_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_AVERAGE_MATURITY", VALUEFUNC(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(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(YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTOAVGMATURITY", VALUEFUNC(YieldType_YIELDTOAVGMATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTOLONGESTAVERAGELIFE", VALUEFUNC(YieldType_YIELDTOLONGESTAVERAGELIFE_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(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(YieldType_SEMI_ANNUAL_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MOST_RECENT_CLOSING_YIELD", VALUEFUNC(YieldType_MOST_RECENT_CLOSING_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE", VALUEFUNC(YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSING_YIELD", VALUEFUNC(YieldType_CLOSING_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDINFLATIONASSUMPTION", VALUEFUNC(YieldType_YIELDINFLATIONASSUMPTION_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(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_TRUEYIELD", VALUEFUNC(YieldType_TRUEYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_CLOSINGYIELDMOSTRECENTQUARTER", VALUEFUNC(YieldType_CLOSINGYIELDMOSTRECENTQUARTER_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_VALUE_OF_1_32", VALUEFUNC(YieldType_YIELD_VALUE_OF_1_32_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE", VALUEFUNC(YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_INVFLOATERBONDYIELD", VALUEFUNC(YieldType_INVFLOATERBONDYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE", VALUEFUNC(YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTONEXTPUT", VALUEFUNC(YieldType_YIELDTONEXTPUT_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDTONEXTCALL", VALUEFUNC(YieldType_YIELDTONEXTCALL_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS", VALUEFUNC(YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_BOOKYIELD", VALUEFUNC(YieldType_BOOKYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "YieldType_YIELDVALUEOF132", VALUEFUNC(YieldType_YIELDVALUEOF132_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_NATIONAL_XXCLUDING_LOCAL", VALUEFUNC(PegScope_NATIONAL_XXCLUDING_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_NATIONAL_EXCLUDING_LOCAL", VALUEFUNC(PegScope_NATIONAL_EXCLUDING_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_LOCAL", VALUEFUNC(PegScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_NATIONALEXCLUDINGLOCAL", VALUEFUNC(PegScope_NATIONALEXCLUDINGLOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_GLOBAL", VALUEFUNC(PegScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_NATIONAL", VALUEFUNC(PegScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegScope_LOCALEXCHANGEECNATS", VALUEFUNC(PegScope_LOCALEXCHANGEECNATS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_TRI_PARTY", VALUEFUNC(SettlDeliveryType_TRI_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_HOLD_IN_CUSTODY", VALUEFUNC(SettlDeliveryType_HOLD_IN_CUSTODY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_FREE", VALUEFUNC(SettlDeliveryType_FREE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_VERSUS_PAYMENT_DELIVER", VALUEFUNC(SettlDeliveryType_VERSUS_PAYMENT_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_FREE_DELIVER", VALUEFUNC(SettlDeliveryType_FREE_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlDeliveryType_VERSUS_PAYMENT", VALUEFUNC(SettlDeliveryType_VERSUS_PAYMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_STRICT", VALUEFUNC(DiscretionLimitType_STRICT_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_ORWORSE", VALUEFUNC(DiscretionLimitType_ORWORSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_OR_BETTER", VALUEFUNC(DiscretionLimitType_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_OR_WORSE", VALUEFUNC(DiscretionLimitType_OR_WORSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionLimitType_ORBETTER", VALUEFUNC(DiscretionLimitType_ORBETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE", VALUEFUNC(PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE", VALUEFUNC(PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_VALID_REQUEST", VALUEFUNC(PartyDetailsRequestResult_VALID_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED", VALUEFUNC(PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA", VALUEFUNC(PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST", VALUEFUNC(PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_OTHER", VALUEFUNC(PartyDetailsRequestResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA", VALUEFUNC(PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseMethod_AUTOMATIC", VALUEFUNC(ExerciseMethod_AUTOMATIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseMethod_MANUAL", VALUEFUNC(ExerciseMethod_MANUAL_get), 0);
  rb_define_singleton_method(mQuickfix, "WorkingIndicator_NO", VALUEFUNC(WorkingIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "WorkingIndicator_YES", VALUEFUNC(WorkingIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY", VALUEFUNC(SideMultiLegReportingType_INDIVIDUALLEGOFAMULTILEGSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_SINGLE_SECURITY", VALUEFUNC(SideMultiLegReportingType_SINGLE_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_MULTILEG_SECURITY", VALUEFUNC(SideMultiLegReportingType_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY", VALUEFUNC(SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_MULTILEGSECURITY", VALUEFUNC(SideMultiLegReportingType_MULTILEGSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SideMultiLegReportingType_SINGLESECURITY", VALUEFUNC(SideMultiLegReportingType_SINGLESECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS", VALUEFUNC(ConfirmRejReason_MISSINGSETTLEMENTINSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS", VALUEFUNC(ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_MISMATCHEDACCOUNT", VALUEFUNC(ConfirmRejReason_MISMATCHEDACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_MISMATCHED_ACCOUNT", VALUEFUNC(ConfirmRejReason_MISMATCHED_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmRejReason_OTHER", VALUEFUNC(ConfirmRejReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "BidRequestTransType_NEW", VALUEFUNC(BidRequestTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "BidRequestTransType_NO", VALUEFUNC(BidRequestTransType_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "BidRequestTransType_CANCEL", VALUEFUNC(BidRequestTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED", VALUEFUNC(MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_OTHER", VALUEFUNC(MassActionRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT", VALUEFUNC(MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollApplType_GENERAL", VALUEFUNC(CollApplType_GENERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollApplType_SPECIFIC_DEPOSIT", VALUEFUNC(CollApplType_SPECIFIC_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmType_CONFIRMATION", VALUEFUNC(ConfirmType_CONFIRMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmType_CONFIRMATION_REQUEST_REJECTED", VALUEFUNC(ConfirmType_CONFIRMATION_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmType_CONFIRMATIONREQUESTREJECTED", VALUEFUNC(ConfirmType_CONFIRMATIONREQUESTREJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmType_STATUS", VALUEFUNC(ConfirmType_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_INDICATIVE", VALUEFUNC(MDQuoteType_INDICATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_RESTRICTED_TRADEABLE", VALUEFUNC(MDQuoteType_RESTRICTED_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_INDICATIVE_AND_TRADEABLE", VALUEFUNC(MDQuoteType_INDICATIVE_AND_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_TRADEABLE", VALUEFUNC(MDQuoteType_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDQuoteType_COUNTER", VALUEFUNC(MDQuoteType_COUNTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QtyType_CONTRACTS", VALUEFUNC(QtyType_CONTRACTS_get), 0);
  rb_define_singleton_method(mQuickfix, "QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT", VALUEFUNC(QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "QtyType_UNITS", VALUEFUNC(QtyType_UNITS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_END_TRADE", VALUEFUNC(QuoteRespType_END_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_HITLIFT", VALUEFUNC(QuoteRespType_HITLIFT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_HIT_LIFT", VALUEFUNC(QuoteRespType_HIT_LIFT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_COVER", VALUEFUNC(QuoteRespType_COVER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_DONE_AWAY", VALUEFUNC(QuoteRespType_DONE_AWAY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_DONEAWAY", VALUEFUNC(QuoteRespType_DONEAWAY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_TIMED_OUT", VALUEFUNC(QuoteRespType_TIMED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_PASS", VALUEFUNC(QuoteRespType_PASS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_EXPIRED", VALUEFUNC(QuoteRespType_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRespType_COUNTER", VALUEFUNC(QuoteRespType_COUNTER_get), 0);
  rb_define_singleton_method(mQuickfix, "IOINaturalFlag_NO", VALUEFUNC(IOINaturalFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "IOINaturalFlag_YES", VALUEFUNC(IOINaturalFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligSource_INSTRUCTIONS_OF_BROKER", VALUEFUNC(SettlObligSource_INSTRUCTIONS_OF_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligSource_INVESTOR", VALUEFUNC(SettlObligSource_INVESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION", VALUEFUNC(SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ON_HOURS_TRADE", VALUEFUNC(TrdSubType_ON_HOURS_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_INTERIM_PROTECTED_TRADE", VALUEFUNC(TrdSubType_INTERIM_PROTECTED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_K", VALUEFUNC(TrdSubType_K_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_LC", VALUEFUNC(TrdSubType_LC_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_WN", VALUEFUNC(TrdSubType_WN_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_CONVERTED_SWAP", VALUEFUNC(TrdSubType_CONVERTED_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_B", VALUEFUNC(TrdSubType_B_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_M", VALUEFUNC(TrdSubType_M_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_RT", VALUEFUNC(TrdSubType_RT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ONSET_DUE_TO_AN_ALLOCATION", VALUEFUNC(TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_CMTA", VALUEFUNC(TrdSubType_CMTA_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT", VALUEFUNC(TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_DIFFERENTIAL_SPREAD", VALUEFUNC(TrdSubType_DIFFERENTIAL_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_TRANSACTION_FROM_EXERCISE", VALUEFUNC(TrdSubType_TRANSACTION_FROM_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_TRANSACTION_FROM_ASSIGNMENT", VALUEFUNC(TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_N", VALUEFUNC(TrdSubType_N_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT", VALUEFUNC(TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_NR", VALUEFUNC(TrdSubType_NR_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_SW", VALUEFUNC(TrdSubType_SW_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_OTC_QUOTE", VALUEFUNC(TrdSubType_OTC_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ADVISORY_FOR_CONTRA_SIDE", VALUEFUNC(TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION", VALUEFUNC(TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_P", VALUEFUNC(TrdSubType_P_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_CROSSED_TRADE", VALUEFUNC(TrdSubType_CROSSED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_PA", VALUEFUNC(TrdSubType_PA_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT", VALUEFUNC(TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_R", VALUEFUNC(TrdSubType_R_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_RO", VALUEFUNC(TrdSubType_RO_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_WT", VALUEFUNC(TrdSubType_WT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_OFF_HOURS_TRADE", VALUEFUNC(TrdSubType_OFF_HOURS_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_REJECT_FOR_SUBMITTING_SIDE", VALUEFUNC(TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ONSET_DUT_TO_AN_ALLOCATION", VALUEFUNC(TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_AI", VALUEFUNC(TrdSubType_AI_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_PC", VALUEFUNC(TrdSubType_PC_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_PN", VALUEFUNC(TrdSubType_PN_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_LARGE_IN_SCALE", VALUEFUNC(TrdSubType_LARGE_IN_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_NM", VALUEFUNC(TrdSubType_NM_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_T", VALUEFUNC(TrdSubType_T_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdSubType_ACATS", VALUEFUNC(TrdSubType_ACATS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_NEW", VALUEFUNC(ExecTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_CORRECT", VALUEFUNC(ExecTransType_CORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_CANCEL", VALUEFUNC(ExecTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecTransType_STATUS", VALUEFUNC(ExecTransType_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR", VALUEFUNC(DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_ACCUMULATE", VALUEFUNC(DayBookingInst_ACCUMULATE_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST", VALUEFUNC(DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_SPEAK_FIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO", VALUEFUNC(DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_AUTO_get), 0);
  rb_define_singleton_method(mQuickfix, "DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING", VALUEFUNC(DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_EASTERN_OFF_PEAK", VALUEFUNC(FlowScheduleType_NERC_EASTERN_OFF_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_WESTERN_PEAK", VALUEFUNC(FlowScheduleType_NERC_WESTERN_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_EASTERN_PEAK", VALUEFUNC(FlowScheduleType_NERC_EASTERN_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH", VALUEFUNC(FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "FlowScheduleType_NERC_WESTERN_OFF_PEAK", VALUEFUNC(FlowScheduleType_NERC_WESTERN_OFF_PEAK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDOriginType_CROSS", VALUEFUNC(MDOriginType_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDOriginType_OFF_BOOK", VALUEFUNC(MDOriginType_OFF_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDOriginType_BOOK", VALUEFUNC(MDOriginType_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_ACCEPTED_WITH_WARNINGS", VALUEFUNC(CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_COMPLETED", VALUEFUNC(CollInquiryStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_ACCEPTEDWITHWARNINGS", VALUEFUNC(CollInquiryStatus_ACCEPTEDWITHWARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_REJECTED", VALUEFUNC(CollInquiryStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_COMPLETEDWITHWARNINGS", VALUEFUNC(CollInquiryStatus_COMPLETEDWITHWARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_ACCEPTED", VALUEFUNC(CollInquiryStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollInquiryStatus_COMPLETED_WITH_WARNINGS", VALUEFUNC(CollInquiryStatus_COMPLETED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_3A3", VALUEFUNC(CPProgram_3A3_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_OTHER", VALUEFUNC(CPProgram_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_3", VALUEFUNC(CPProgram_3_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_42", VALUEFUNC(CPProgram_42_get), 0);
  rb_define_singleton_method(mQuickfix, "CPProgram_4", VALUEFUNC(CPProgram_4_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_POSITIONS", VALUEFUNC(PosReqType_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_BACKOUT_MESSAGE", VALUEFUNC(PosReqType_BACKOUT_MESSAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_DELTA_POSITIONS", VALUEFUNC(PosReqType_DELTA_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_SETTLEMENT_ACTIVITY", VALUEFUNC(PosReqType_SETTLEMENT_ACTIVITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_TRADES", VALUEFUNC(PosReqType_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_EXERCISES", VALUEFUNC(PosReqType_EXERCISES_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqType_ASSIGNMENTS", VALUEFUNC(PosReqType_ASSIGNMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY", VALUEFUNC(MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSSECURITYTYPE", VALUEFUNC(MassStatusReqType_STATUSSECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE", VALUEFUNC(MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSTRDSESSION", VALUEFUNC(MassStatusReqType_STATUSTRDSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID", VALUEFUNC(MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_SECURITY_ISSUER", VALUEFUNC(MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSCFICODE", VALUEFUNC(MassStatusReqType_STATUSCFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSUNDERLYINGSECURITY", VALUEFUNC(MassStatusReqType_STATUSUNDERLYINGSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSPARTYID", VALUEFUNC(MassStatusReqType_STATUSPARTYID_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT", VALUEFUNC(MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ALL_ORDERS", VALUEFUNC(MassStatusReqType_STATUS_FOR_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSSECURITY", VALUEFUNC(MassStatusReqType_STATUSSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSPRODUCT", VALUEFUNC(MassStatusReqType_STATUSPRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassStatusReqType_STATUSALLORDERS", VALUEFUNC(MassStatusReqType_STATUSALLORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST", VALUEFUNC(SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES", VALUEFUNC(SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_SNAPSHOTUPDATE", VALUEFUNC(SubscriptionRequestType_SNAPSHOTUPDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_SNAPSHOT", VALUEFUNC(SubscriptionRequestType_SNAPSHOT_get), 0);
  rb_define_singleton_method(mQuickfix, "SubscriptionRequestType_UNSUBSCRIBE", VALUEFUNC(SubscriptionRequestType_UNSUBSCRIBE_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_MARKETPLACE_NEWS", VALUEFUNC(NewsCategory_MARKETPLACE_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_TECHNICAL_NEWS", VALUEFUNC(NewsCategory_TECHNICAL_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_COMPANY_NEWS", VALUEFUNC(NewsCategory_COMPANY_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_OTHER_NEWS", VALUEFUNC(NewsCategory_OTHER_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsCategory_FINANCIAL_MARKET_NEWS", VALUEFUNC(NewsCategory_FINANCIAL_MARKET_NEWS_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_MEDIUM", VALUEFUNC(IOIQty_MEDIUM_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_1000000000", VALUEFUNC(IOIQty_1000000000_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_LARGE", VALUEFUNC(IOIQty_LARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_SMALL", VALUEFUNC(IOIQty_SMALL_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQty_UNDISCLOSED_QUANTITY", VALUEFUNC(IOIQty_UNDISCLOSED_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION", VALUEFUNC(ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseError_APPLICATION_DOES_NOT_EXIST", VALUEFUNC(ApplResponseError_APPLICATION_DOES_NOT_EXIST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE", VALUEFUNC(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(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(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_ADDEDLIQUIDITY", VALUEFUNC(LastLiquidityInd_ADDEDLIQUIDITY_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_LIQUIDITY_ROUTED_OUT", VALUEFUNC(LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_LIQUIDITYROUTEDOUT", VALUEFUNC(LastLiquidityInd_LIQUIDITYROUTEDOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_AUCTION", VALUEFUNC(LastLiquidityInd_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_REMOVEDLIQUIDITY", VALUEFUNC(LastLiquidityInd_REMOVEDLIQUIDITY_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_ADDED_LIQUIDITY", VALUEFUNC(LastLiquidityInd_ADDED_LIQUIDITY_get), 0);
  rb_define_singleton_method(mQuickfix, "LastLiquidityInd_REMOVED_LIQUIDITY", VALUEFUNC(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(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(StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceDeterminationMethod_FIXED_STRIKE", VALUEFUNC(StrikePriceDeterminationMethod_FIXED_STRIKE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE", VALUEFUNC(StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_MININIZEMARKETIMPACT", VALUEFUNC(TargetStrategy_MININIZEMARKETIMPACT_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES", VALUEFUNC(TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_PARTICIPATE", VALUEFUNC(TargetStrategy_PARTICIPATE_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_MININIZE_MARKET_IMPACT", VALUEFUNC(TargetStrategy_MININIZE_MARKET_IMPACT_get), 0);
  rb_define_singleton_method(mQuickfix, "TargetStrategy_VWAP", VALUEFUNC(TargetStrategy_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "DueToRelated_NO", VALUEFUNC(DueToRelated_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "DueToRelated_YES", VALUEFUNC(DueToRelated_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingCashType_DIFF", VALUEFUNC(UnderlyingCashType_DIFF_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingCashType_FIXED", VALUEFUNC(UnderlyingCashType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT", VALUEFUNC(CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT", VALUEFUNC(CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER", VALUEFUNC(CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderCapacity_ALL_OTHER", VALUEFUNC(CustOrderCapacity_ALL_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnershipType_JOINT_TRUSTEES", VALUEFUNC(OwnershipType_JOINT_TRUSTEES_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnershipType_JOINT_INVESTORS", VALUEFUNC(OwnershipType_JOINT_INVESTORS_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnershipType_TENANTS_IN_COMMON", VALUEFUNC(OwnershipType_TENANTS_IN_COMMON_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_US_DOLLARS", VALUEFUNC(UnitOfMeasure_US_DOLLARS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_TROY_OUNCES", VALUEFUNC(UnitOfMeasure_TROY_OUNCES_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_TONS", VALUEFUNC(UnitOfMeasure_TONS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_BILLION_CUBIC_FEET", VALUEFUNC(UnitOfMeasure_BILLION_CUBIC_FEET_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_ONE_MILLION_BTU", VALUEFUNC(UnitOfMeasure_ONE_MILLION_BTU_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_MEGAWATT_HOURS", VALUEFUNC(UnitOfMeasure_MEGAWATT_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_MILLION_BARRELS", VALUEFUNC(UnitOfMeasure_MILLION_BARRELS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_GALLONS", VALUEFUNC(UnitOfMeasure_GALLONS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_BARRELS", VALUEFUNC(UnitOfMeasure_BARRELS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_POUNDS", VALUEFUNC(UnitOfMeasure_POUNDS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_METRIC_TONS", VALUEFUNC(UnitOfMeasure_METRIC_TONS_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_ALLOWANCES", VALUEFUNC(UnitOfMeasure_ALLOWANCES_get), 0);
  rb_define_singleton_method(mQuickfix, "UnitOfMeasure_BUSHELS", VALUEFUNC(UnitOfMeasure_BUSHELS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_INVALID_DEFINITION_REQUEST", VALUEFUNC(SecDefStatus_INVALID_DEFINITION_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_PENDING_APPROVAL", VALUEFUNC(SecDefStatus_PENDING_APPROVAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_APPROVED", VALUEFUNC(SecDefStatus_APPROVED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_UNAUTHORIZEDREQUEST", VALUEFUNC(SecDefStatus_UNAUTHORIZEDREQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_PENDINGAPPROVAL", VALUEFUNC(SecDefStatus_PENDINGAPPROVAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_UNAUTHORIZED_REQUEST", VALUEFUNC(SecDefStatus_UNAUTHORIZED_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_INVALIDDEFINITIONREQUEST", VALUEFUNC(SecDefStatus_INVALIDDEFINITIONREQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_APPROVEDACCEPTED", VALUEFUNC(SecDefStatus_APPROVEDACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecDefStatus_REJECTED", VALUEFUNC(SecDefStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_WHEN_AND_IF_ISSUED", VALUEFUNC(SettlmntTyp_WHEN_AND_IF_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_1", VALUEFUNC(SettlmntTyp_T_PLUS_1_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_FUTURE", VALUEFUNC(SettlmntTyp_FUTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_SELLERS_OPTION", VALUEFUNC(SettlmntTyp_SELLERS_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_2", VALUEFUNC(SettlmntTyp_T_PLUS_2_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_3", VALUEFUNC(SettlmntTyp_T_PLUS_3_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_4", VALUEFUNC(SettlmntTyp_T_PLUS_4_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_REGULAR", VALUEFUNC(SettlmntTyp_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_T_PLUS_5", VALUEFUNC(SettlmntTyp_T_PLUS_5_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_WHEN_ISSUED", VALUEFUNC(SettlmntTyp_WHEN_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_NEXT_DAY", VALUEFUNC(SettlmntTyp_NEXT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlmntTyp_CASH", VALUEFUNC(SettlmntTyp_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradePublishIndicator_DO_NOT_PUBLISH_TRADE", VALUEFUNC(TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradePublishIndicator_DEFERRED_PUBLICATION", VALUEFUNC(TradePublishIndicator_DEFERRED_PUBLICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradePublishIndicator_PUBLISH_TRADE", VALUEFUNC(TradePublishIndicator_PUBLISH_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseType_MESSAGES_NOT_AVAILABLE", VALUEFUNC(ApplResponseType_MESSAGES_NOT_AVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseType_APPLICATION_DOES_NOT_EXIST", VALUEFUNC(ApplResponseType_APPLICATION_DOES_NOT_EXIST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED", VALUEFUNC(ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_SID", VALUEFUNC(StandInstDbType_SID_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_DTC_SID", VALUEFUNC(StandInstDbType_DTC_SID_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_CUSTODIAN", VALUEFUNC(StandInstDbType_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_ALERT", VALUEFUNC(StandInstDbType_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_ACCOUNTNET", VALUEFUNC(StandInstDbType_ACCOUNTNET_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_A_GLOBAL_CUSTODIAN", VALUEFUNC(StandInstDbType_A_GLOBAL_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_THOMSON_ALERT", VALUEFUNC(StandInstDbType_THOMSON_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "StandInstDbType_OTHER", VALUEFUNC(StandInstDbType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_CROSS_MARKET_WARNING", VALUEFUNC(QuoteEntryStatus_CROSS_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_LOCKED_MARKET_WARNING", VALUEFUNC(QuoteEntryStatus_LOCKED_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET", VALUEFUNC(QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET", VALUEFUNC(QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_REJECTED", VALUEFUNC(QuoteEntryStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_EXPIRED", VALUEFUNC(QuoteEntryStatus_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_REMOVED_FROM_MARKET", VALUEFUNC(QuoteEntryStatus_REMOVED_FROM_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_ACCEPTED", VALUEFUNC(QuoteEntryStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteEntryStatus_ACTIVE", VALUEFUNC(QuoteEntryStatus_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_MID", VALUEFUNC(TriggerPriceType_BEST_MID_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_BID_OR_LAST_TRADE", VALUEFUNC(TriggerPriceType_BEST_BID_OR_LAST_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_BID", VALUEFUNC(TriggerPriceType_BEST_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_OFFER_OR_LAST_TRADE", VALUEFUNC(TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_BEST_OFFER", VALUEFUNC(TriggerPriceType_BEST_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceType_LAST_TRADE", VALUEFUNC(TriggerPriceType_LAST_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_EXTERNAL_TRANSFER", VALUEFUNC(SideTrdSubTyp_EXTERNAL_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT", VALUEFUNC(SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_TRANSACTION_FROM_EXERCISE", VALUEFUNC(SideTrdSubTyp_TRANSACTION_FROM_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_DIFFERENTIAL_SPREAD", VALUEFUNC(SideTrdSubTyp_DIFFERENTIAL_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION", VALUEFUNC(SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE", VALUEFUNC(SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_CMTA", VALUEFUNC(SideTrdSubTyp_CMTA_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT", VALUEFUNC(SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_INTERNAL_TRANSFER", VALUEFUNC(SideTrdSubTyp_INTERNAL_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION", VALUEFUNC(SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE", VALUEFUNC(SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST", VALUEFUNC(SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND", VALUEFUNC(SettlInstReqRejCode_NOMATCHINGSETTLEMENTINSTRUCTIONSFOUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_UNKNOWNACCOUNT", VALUEFUNC(SettlInstReqRejCode_UNKNOWNACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_UNABLETOPROCESSREQUEST", VALUEFUNC(SettlInstReqRejCode_UNABLETOPROCESSREQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_UNKNOWN_ACCOUNT", VALUEFUNC(SettlInstReqRejCode_UNKNOWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND", VALUEFUNC(SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstReqRejCode_OTHER", VALUEFUNC(SettlInstReqRejCode_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "Urgency_FLASH", VALUEFUNC(Urgency_FLASH_get), 0);
  rb_define_singleton_method(mQuickfix, "Urgency_NORMAL", VALUEFUNC(Urgency_NORMAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Urgency_BACKGROUND", VALUEFUNC(Urgency_BACKGROUND_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_REPLACE", VALUEFUNC(CollAsgnTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_NEW", VALUEFUNC(CollAsgnTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_REVERSE", VALUEFUNC(CollAsgnTransType_REVERSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_CANCEL", VALUEFUNC(CollAsgnTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnTransType_RELEASE", VALUEFUNC(CollAsgnTransType_RELEASE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_FED_WIRE", VALUEFUNC(PaymentMethod_FED_WIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_ACHCREDIT", VALUEFUNC(PaymentMethod_ACHCREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_TELEGRAPHICTRANSFER", VALUEFUNC(PaymentMethod_TELEGRAPHICTRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DIRECTDEBITBECS", VALUEFUNC(PaymentMethod_DIRECTDEBITBECS_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_EUROCLEAR", VALUEFUNC(PaymentMethod_EUROCLEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_ACH_CREDIT", VALUEFUNC(PaymentMethod_ACH_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_TELEGRAPHIC_TRANSFER", VALUEFUNC(PaymentMethod_TELEGRAPHIC_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_FEDWIRE", VALUEFUNC(PaymentMethod_FEDWIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CREDITCARD", VALUEFUNC(PaymentMethod_CREDITCARD_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DIRECT_DEBIT", VALUEFUNC(PaymentMethod_DIRECT_DEBIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CREDIT_CARD", VALUEFUNC(PaymentMethod_CREDIT_CARD_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CHEQUE", VALUEFUNC(PaymentMethod_CHEQUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DIRECT_CREDIT", VALUEFUNC(PaymentMethod_DIRECT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CREST", VALUEFUNC(PaymentMethod_CREST_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM", VALUEFUNC(PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DEBITCARD", VALUEFUNC(PaymentMethod_DEBITCARD_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_CLEARSTREAM", VALUEFUNC(PaymentMethod_CLEARSTREAM_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_BPAY", VALUEFUNC(PaymentMethod_BPAY_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS", VALUEFUNC(PaymentMethod_HIGHVALUECLEARINGSYSTEMHVACS_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_NSCC", VALUEFUNC(PaymentMethod_NSCC_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DEBIT_CARD", VALUEFUNC(PaymentMethod_DEBIT_CARD_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_ACHDEBIT", VALUEFUNC(PaymentMethod_ACHDEBIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_DIRECTCREDITBECS", VALUEFUNC(PaymentMethod_DIRECTCREDITBECS_get), 0);
  rb_define_singleton_method(mQuickfix, "PaymentMethod_ACH_DEBIT", VALUEFUNC(PaymentMethod_ACH_DEBIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_LOCAL", VALUEFUNC(TriggerPriceTypeScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_NONE", VALUEFUNC(TriggerPriceTypeScope_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_GLOBAL", VALUEFUNC(TriggerPriceTypeScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerPriceTypeScope_NATIONAL", VALUEFUNC(TriggerPriceTypeScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_STRICT", VALUEFUNC(PegLimitType_STRICT_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_ORWORSE", VALUEFUNC(PegLimitType_ORWORSE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_OR_BETTER", VALUEFUNC(PegLimitType_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_OR_WORSE", VALUEFUNC(PegLimitType_OR_WORSE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegLimitType_ORBETTER", VALUEFUNC(PegLimitType_ORBETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BORROW", VALUEFUNC(Side_BORROW_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELLPLUS", VALUEFUNC(Side_SELLPLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BUY_MINUS", VALUEFUNC(Side_BUY_MINUS_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BUYMIN", VALUEFUNC(Side_BUYMIN_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_ASDEFINED", VALUEFUNC(Side_ASDEFINED_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SUBSCRIBE", VALUEFUNC(Side_SUBSCRIBE_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS_SHORT_EXEMPT", VALUEFUNC(Side_CROSS_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_UNDISCLOSED", VALUEFUNC(Side_UNDISCLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELLSHT", VALUEFUNC(Side_SELLSHT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELLSHTEX", VALUEFUNC(Side_SELLSHTEX_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSSSHORTEX", VALUEFUNC(Side_CROSSSHORTEX_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS", VALUEFUNC(Side_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL_SHORT_EXEMPT", VALUEFUNC(Side_SELL_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_UNDISC", VALUEFUNC(Side_UNDISC_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSSSHORT", VALUEFUNC(Side_CROSSSHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BORROWFINANCING", VALUEFUNC(Side_BORROWFINANCING_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_BUY", VALUEFUNC(Side_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS_SHORT_EXXMPT", VALUEFUNC(Side_CROSS_SHORT_EXXMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL", VALUEFUNC(Side_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_LEND", VALUEFUNC(Side_LEND_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL_SHORT", VALUEFUNC(Side_SELL_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_OPPOSITE", VALUEFUNC(Side_OPPOSITE_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_CROSS_SHORT", VALUEFUNC(Side_CROSS_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_SELL_PLUS", VALUEFUNC(Side_SELL_PLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_REDEEM", VALUEFUNC(Side_REDEEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_LENDFINANCING", VALUEFUNC(Side_LENDFINANCING_get), 0);
  rb_define_singleton_method(mQuickfix, "Side_AS_DEFINED", VALUEFUNC(Side_AS_DEFINED_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSIONAMT", VALUEFUNC(ContAmtType_COMMISSIONAMT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUNDBASEDRENEWALCOMM", VALUEFUNC(ContAmtType_FUNDBASEDRENEWALCOMM_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIALCHARGEPCT", VALUEFUNC(ContAmtType_INITIALCHARGEPCT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXITCHARGEAMT", VALUEFUNC(ContAmtType_EXITCHARGEAMT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXIT_CHARGE", VALUEFUNC(ContAmtType_EXIT_CHARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTION_LEVY_AMOUNT", VALUEFUNC(ContAmtType_DILUTION_LEVY_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTION_LEVY_PERCENT", VALUEFUNC(ContAmtType_DILUTION_LEVY_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNT_AMOUNT", VALUEFUNC(ContAmtType_DISCOUNT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSION", VALUEFUNC(ContAmtType_COMMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIAL_CHARGE_PERCENT", VALUEFUNC(ContAmtType_INITIAL_CHARGE_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTIONLEVYAMT", VALUEFUNC(ContAmtType_DILUTIONLEVYAMT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTION_LEVY", VALUEFUNC(ContAmtType_DILUTION_LEVY_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSION_AMOUNT", VALUEFUNC(ContAmtType_COMMISSION_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_NET_SETTLEMENT_AMOUNT", VALUEFUNC(ContAmtType_NET_SETTLEMENT_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXITCHARGEPCT", VALUEFUNC(ContAmtType_EXITCHARGEPCT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSIONPCT", VALUEFUNC(ContAmtType_COMMISSIONPCT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION", VALUEFUNC(ContAmtType_FUND_BASED_RENEWAL_COMMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNT", VALUEFUNC(ContAmtType_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUNDBASEDRENEWALCOMMAMTORD", VALUEFUNC(ContAmtType_FUNDBASEDRENEWALCOMMAMTORD_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNTPCT", VALUEFUNC(ContAmtType_DISCOUNTPCT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13", VALUEFUNC(ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXIT_CHARGE_AMOUNT", VALUEFUNC(ContAmtType_EXIT_CHARGE_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIAL_CHARGE", VALUEFUNC(ContAmtType_INITIAL_CHARGE_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_EXIT_CHARGE_PERCENT", VALUEFUNC(ContAmtType_EXIT_CHARGE_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNT_PERCENT", VALUEFUNC(ContAmtType_DISCOUNT_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIALCHARGEAMT", VALUEFUNC(ContAmtType_INITIALCHARGEAMT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DILUTIONLEVYPCT", VALUEFUNC(ContAmtType_DILUTIONLEVYPCT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14", VALUEFUNC(ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ", VALUEFUNC(ContAmtType_FUNDBASEDRENEWALCOMMAMTPROJ_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_NETSETTLEMENTAMOUNT", VALUEFUNC(ContAmtType_NETSETTLEMENTAMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_PROJECTEDFUNDVALUE", VALUEFUNC(ContAmtType_PROJECTEDFUNDVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_DISCOUNTAMT", VALUEFUNC(ContAmtType_DISCOUNTAMT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT", VALUEFUNC(ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_COMMISSION_PERCENT", VALUEFUNC(ContAmtType_COMMISSION_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_PROJECTED_FUND_VALUE", VALUEFUNC(ContAmtType_PROJECTED_FUND_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "ContAmtType_INITIAL_CHARGE_AMOUNT", VALUEFUNC(ContAmtType_INITIAL_CHARGE_AMOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_IMPLIED_ORDER", VALUEFUNC(OrderCategory_IMPLIED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_STREAMING_PRICE", VALUEFUNC(OrderCategory_STREAMING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_QUOTE_REQUEST", VALUEFUNC(OrderCategory_QUOTE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_CROSS_ORDER", VALUEFUNC(OrderCategory_CROSS_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_MULTILEG_ORDER", VALUEFUNC(OrderCategory_MULTILEG_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_PRIVATELY_NEGOTIATED_TRADE", VALUEFUNC(OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_QUOTE", VALUEFUNC(OrderCategory_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_ORDER", VALUEFUNC(OrderCategory_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderCategory_LINKED_ORDER", VALUEFUNC(OrderCategory_LINKED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_REPLACE", VALUEFUNC(AdvTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_NEW", VALUEFUNC(AdvTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_ADVCANCEL", VALUEFUNC(AdvTransType_ADVCANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_ADVREPLACE", VALUEFUNC(AdvTransType_ADVREPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_ADVNEW", VALUEFUNC(AdvTransType_ADVNEW_get), 0);
  rb_define_singleton_method(mQuickfix, "AdvTransType_CANCEL", VALUEFUNC(AdvTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PublishTrdIndicator_NO", VALUEFUNC(PublishTrdIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PublishTrdIndicator_YES", VALUEFUNC(PublishTrdIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_ACCPTSECPROPREV", VALUEFUNC(SecurityResponseType_ACCPTSECPROPREV_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_SECLISTTYPESRET", VALUEFUNC(SecurityResponseType_SECLISTTYPESRET_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST", VALUEFUNC(SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST", VALUEFUNC(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(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(SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_ACCPTSECPROP", VALUEFUNC(SecurityResponseType_ACCPTSECPROP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_REJECT_SECURITY_PROPOSAL", VALUEFUNC(SecurityResponseType_REJECT_SECURITY_PROPOSAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_SECLISTRET", VALUEFUNC(SecurityResponseType_SECLISTRET_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_REJSECPROP", VALUEFUNC(SecurityResponseType_REJSECPROP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA", VALUEFUNC(SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA", VALUEFUNC(SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityResponseType_NOMATCH", VALUEFUNC(SecurityResponseType_NOMATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_PASSWORD_EXPIRED", VALUEFUNC(SessionStatus_PASSWORD_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_LOGOUT_COMPLETE", VALUEFUNC(SessionStatus_SESSION_LOGOUT_COMPLETE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_INVALID_USERNAME_OR_PASSWORD", VALUEFUNC(SessionStatus_INVALID_USERNAME_OR_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_ACTIVE", VALUEFUNC(SessionStatus_SESSION_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_PASSWORD_CHANGED", VALUEFUNC(SessionStatus_SESSION_PASSWORD_CHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_ACCOUNT_LOCKED", VALUEFUNC(SessionStatus_ACCOUNT_LOCKED_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME", VALUEFUNC(SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE", VALUEFUNC(SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY", VALUEFUNC(SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_JBO", VALUEFUNC(AllocAccountType_JBO_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_HOUSE_TRADER", VALUEFUNC(AllocAccountType_HOUSE_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_FLOOR_TRADER", VALUEFUNC(AllocAccountType_FLOOR_TRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED", VALUEFUNC(AllocAccountType_ACCOUNTISHOUSETRADERANDISCROSSMARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS", VALUEFUNC(AllocAccountType_ACCOUNTISCARRIEDONCUSTOMERSIDEOFBOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT", VALUEFUNC(AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED", VALUEFUNC(AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKSANDISCROSSMARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_HOUSETRADER", VALUEFUNC(AllocAccountType_HOUSETRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_FLOORTRADER", VALUEFUNC(AllocAccountType_FLOORTRADER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED", VALUEFUNC(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_PN_CUSTOMER_SIDE_OF_BOOKS", VALUEFUNC(AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS", VALUEFUNC(AllocAccountType_ACCOUNTISCARRIEDONNONCUSTOMERSIDEOFBOOKS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED", VALUEFUNC(AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_REPLACE", VALUEFUNC(AllocTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_NEW", VALUEFUNC(AllocTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_CALCULATED", VALUEFUNC(AllocTransType_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_PRELIMINARY", VALUEFUNC(AllocTransType_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_CALCULATEDWITHOUTPRELIMINARY", VALUEFUNC(AllocTransType_CALCULATEDWITHOUTPRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_CANCEL", VALUEFUNC(AllocTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_REVERSAL", VALUEFUNC(AllocTransType_REVERSAL_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocTransType_CALCULATED_WITHOUT_PRELIMINARY", VALUEFUNC(AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_DIFFERENCE", VALUEFUNC(ExpirationQtyType_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_FINAL_WILL_BE_EXERCISED", VALUEFUNC(ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_NON_AUTO_EXERCISE", VALUEFUNC(ExpirationQtyType_NON_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_CONTRARY_INTENTION", VALUEFUNC(ExpirationQtyType_CONTRARY_INTENTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExpirationQtyType_AUTO_EXERCISE", VALUEFUNC(ExpirationQtyType_AUTO_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocHandlInst_FORWARDMATCH", VALUEFUNC(AllocHandlInst_FORWARDMATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocHandlInst_FORWARD_AND_MATCH", VALUEFUNC(AllocHandlInst_FORWARD_AND_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocHandlInst_FORWARD", VALUEFUNC(AllocHandlInst_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocHandlInst_MATCH", VALUEFUNC(AllocHandlInst_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestStatus_COMPLETED", VALUEFUNC(TradeRequestStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestStatus_REJECTED", VALUEFUNC(TradeRequestStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeRequestStatus_ACCEPTED", VALUEFUNC(TradeRequestStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST", VALUEFUNC(PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_PRO_RATA", VALUEFUNC(PreallocMethod_PRO_RATA_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST", VALUEFUNC(PreallocMethod_DO_NOT_PRORATA_DISCUSS_FIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_DO_NOT_PRO_RATA", VALUEFUNC(PreallocMethod_DO_NOT_PRO_RATA_get), 0);
  rb_define_singleton_method(mQuickfix, "PreallocMethod_PRORATA", VALUEFUNC(PreallocMethod_PRORATA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTHIRANONPROTOTYPEUS", VALUEFUNC(TaxAdvantageType_ROTHIRANONPROTOTYPEUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS", VALUEFUNC(TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTROLLOVERUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_PROFITSHARINGPLANUS", VALUEFUNC(TaxAdvantageType_PROFITSHARINGPLANUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_SELF_DIRECTED_IRA", VALUEFUNC(TaxAdvantageType_SELF_DIRECTED_IRA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_401", VALUEFUNC(TaxAdvantageType_401_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER_11", VALUEFUNC(TaxAdvantageType_EMPLOYER_11_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_457US", VALUEFUNC(TaxAdvantageType_457US_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER_12", VALUEFUNC(TaxAdvantageType_EMPLOYER_12_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINI_CASH_ISA", VALUEFUNC(TaxAdvantageType_MINI_CASH_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA", VALUEFUNC(TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_CONVERSION_IRA_26", VALUEFUNC(TaxAdvantageType_ROTH_CONVERSION_IRA_26_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE", VALUEFUNC(TaxAdvantageType_EMPLOYEE_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_SELFDIRECTEDIRAUS", VALUEFUNC(TaxAdvantageType_SELFDIRECTEDIRAUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_403", VALUEFUNC(TaxAdvantageType_403_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NON_FUND_PROTOTYPE_IRA", VALUEFUNC(TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NONFUNDPROTOTYPEIRAUS", VALUEFUNC(TaxAdvantageType_NONFUNDPROTOTYPEIRAUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_CONVERSION_IRA_27", VALUEFUNC(TaxAdvantageType_ROTH_CONVERSION_IRA_27_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS", VALUEFUNC(TaxAdvantageType_ROTHCONVERSIONIRANONPROTOTYPEUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINI_INSURANCE_ISA", VALUEFUNC(TaxAdvantageType_MINI_INSURANCE_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS", VALUEFUNC(TaxAdvantageType_ROTHCONVERSIONIRAFUNDPROTOTYPEUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS", VALUEFUNC(TaxAdvantageType_EDUCATIONIRAFUNDPROTOTYPEUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MAXIISAUK", VALUEFUNC(TaxAdvantageType_MAXIISAUK_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER", VALUEFUNC(TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NONFUNDQUALIFIEDPLANUS", VALUEFUNC(TaxAdvantageType_NONFUNDQUALIFIEDPLANUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER_CURRENT_YEAR", VALUEFUNC(TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_PRIORYEARPAYMENTUS", VALUEFUNC(TaxAdvantageType_PRIORYEARPAYMENTUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_TESSAUK", VALUEFUNC(TaxAdvantageType_TESSAUK_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_CURRENTYEARPAYMENTUS", VALUEFUNC(TaxAdvantageType_CURRENTYEARPAYMENTUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS", VALUEFUNC(TaxAdvantageType_EDUCATIONIRANONPROTOTYPEUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS", VALUEFUNC(TaxAdvantageType_INDIVIDUALRETIREMENTACCOUNTUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_KEOGHUS", VALUEFUNC(TaxAdvantageType_KEOGHUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EDUCATION_IRA_28", VALUEFUNC(TaxAdvantageType_EDUCATION_IRA_28_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_PROFIT_SHARING_PLAN", VALUEFUNC(TaxAdvantageType_PROFIT_SHARING_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NON_FUND_QUALIFIED_PLAN", VALUEFUNC(TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS", VALUEFUNC(TaxAdvantageType_ROTHIRAFUNDPROTOTYPEUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EDUCATION_IRA_29", VALUEFUNC(TaxAdvantageType_EDUCATION_IRA_29_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE_10", VALUEFUNC(TaxAdvantageType_EMPLOYEE_10_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE_9", VALUEFUNC(TaxAdvantageType_EMPLOYEE_9_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEE_CURRENT_YEAR", VALUEFUNC(TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MAXI_ISA", VALUEFUNC(TaxAdvantageType_MAXI_ISA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINIINSURANCEISAUK", VALUEFUNC(TaxAdvantageType_MINIINSURANCEISAUK_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_PRIOR_YEAR_PAYMENT", VALUEFUNC(TaxAdvantageType_PRIOR_YEAR_PAYMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN", VALUEFUNC(TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_401K", VALUEFUNC(TaxAdvantageType_401K_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_403BUS", VALUEFUNC(TaxAdvantageType_403BUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINICASHISAUK", VALUEFUNC(TaxAdvantageType_MINICASHISAUK_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_IRA_24", VALUEFUNC(TaxAdvantageType_ROTH_IRA_24_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_MINISTOCKSANDSHARESISAUK", VALUEFUNC(TaxAdvantageType_MINISTOCKSANDSHARESISAUK_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_OTHER", VALUEFUNC(TaxAdvantageType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYERCURRENTYEARUS", VALUEFUNC(TaxAdvantageType_EMPLOYERCURRENTYEARUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ASSET_TRANSFER", VALUEFUNC(TaxAdvantageType_ASSET_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ROTH_IRA_25", VALUEFUNC(TaxAdvantageType_ROTH_IRA_25_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_KEOGH", VALUEFUNC(TaxAdvantageType_KEOGH_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS", VALUEFUNC(TaxAdvantageType_DEFINEDCONTRIBUTIONPLANUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_401KUS", VALUEFUNC(TaxAdvantageType_401KUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_TESSA", VALUEFUNC(TaxAdvantageType_TESSA_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NONE_NOT_APPLICABLE", VALUEFUNC(TaxAdvantageType_NONE_NOT_APPLICABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_NONE", VALUEFUNC(TaxAdvantageType_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_457", VALUEFUNC(TaxAdvantageType_457_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEEPRIORYEARUS", VALUEFUNC(TaxAdvantageType_EMPLOYEEPRIORYEARUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYERPRIORYEARUS", VALUEFUNC(TaxAdvantageType_EMPLOYERPRIORYEARUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYER", VALUEFUNC(TaxAdvantageType_EMPLOYER_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_EMPLOYEECURRENTYEARUS", VALUEFUNC(TaxAdvantageType_EMPLOYEECURRENTYEARUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16", VALUEFUNC(TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT", VALUEFUNC(TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17", VALUEFUNC(TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_CURRENT_YEAR_PAYMENT", VALUEFUNC(TaxAdvantageType_CURRENT_YEAR_PAYMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TaxAdvantageType_ASSETTRANSFERUS", VALUEFUNC(TaxAdvantageType_ASSETTRANSFERUS_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_EUC_JP", VALUEFUNC(MessageEncoding_EUC_JP_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_SHIFT_JIS", VALUEFUNC(MessageEncoding_SHIFT_JIS_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_UTF_8", VALUEFUNC(MessageEncoding_UTF_8_get), 0);
  rb_define_singleton_method(mQuickfix, "MessageEncoding_ISO_2022_JP", VALUEFUNC(MessageEncoding_ISO_2022_JP_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_TILL_CROSSING", VALUEFUNC(TimeInForce_GOOD_TILL_CROSSING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_FILL_OR_KILL", VALUEFUNC(TimeInForce_FILL_OR_KILL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_TILL_DATE", VALUEFUNC(TimeInForce_GOOD_TILL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_ATTHEOPENING", VALUEFUNC(TimeInForce_ATTHEOPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_FILLORKILL", VALUEFUNC(TimeInForce_FILLORKILL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOODTILLDATE", VALUEFUNC(TimeInForce_GOODTILLDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOODTILLCANCEL", VALUEFUNC(TimeInForce_GOODTILLCANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_ATTHECLOSE", VALUEFUNC(TimeInForce_ATTHECLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_TILL_CANCEL", VALUEFUNC(TimeInForce_GOOD_TILL_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_DAY", VALUEFUNC(TimeInForce_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_AT_CROSSING", VALUEFUNC(TimeInForce_AT_CROSSING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_IMMEDIATEORCANCEL", VALUEFUNC(TimeInForce_IMMEDIATEORCANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_IMMEDIATE_OR_CANCEL", VALUEFUNC(TimeInForce_IMMEDIATE_OR_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOODTILLCROSSING", VALUEFUNC(TimeInForce_GOODTILLCROSSING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_GOOD_THROUGH_CROSSING", VALUEFUNC(TimeInForce_GOOD_THROUGH_CROSSING_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_AT_THE_CLOSE", VALUEFUNC(TimeInForce_AT_THE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeInForce_AT_THE_OPENING", VALUEFUNC(TimeInForce_AT_THE_OPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AON", VALUEFUNC(IOIQualifier_AON_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_THROUGH_THE_DAY", VALUEFUNC(IOIQualifier_THROUGH_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_INDIDCATION", VALUEFUNC(IOIQualifier_INDIDCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_MOC", VALUEFUNC(IOIQualifier_MOC_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_READYTRADE", VALUEFUNC(IOIQualifier_READYTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_ATMID", VALUEFUNC(IOIQualifier_ATMID_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_INDWRKAWAY", VALUEFUNC(IOIQualifier_INDWRKAWAY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_MARKET", VALUEFUNC(IOIQualifier_AT_THE_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_MIDPOINT", VALUEFUNC(IOIQualifier_AT_THE_MIDPOINT_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_CROSSING_OPPORTUNITY", VALUEFUNC(IOIQualifier_CROSSING_OPPORTUNITY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_CURRENT_QUOTE", VALUEFUNC(IOIQualifier_CURRENT_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_IN_TOUCH_WITH", VALUEFUNC(IOIQualifier_IN_TOUCH_WITH_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_ALL_OR_NONE", VALUEFUNC(IOIQualifier_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_THROUGHDAY", VALUEFUNC(IOIQualifier_THROUGHDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_TAKING_A_POSITION", VALUEFUNC(IOIQualifier_TAKING_A_POSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_OPEN", VALUEFUNC(IOIQualifier_AT_THE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_TAKEPOSITION", VALUEFUNC(IOIQualifier_TAKEPOSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PORTFOLIO_SHOW_N", VALUEFUNC(IOIQualifier_PORTFOLIO_SHOW_N_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_INTOUCH", VALUEFUNC(IOIQualifier_INTOUCH_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_MOREBEHIND", VALUEFUNC(IOIQualifier_MOREBEHIND_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_ATMARKET", VALUEFUNC(IOIQualifier_ATMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_CROSSOPP", VALUEFUNC(IOIQualifier_CROSSOPP_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PREOPEN", VALUEFUNC(IOIQualifier_PREOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_ATCLOSE", VALUEFUNC(IOIQualifier_ATCLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_MARKET_ON_CLOSE", VALUEFUNC(IOIQualifier_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_VERSUS", VALUEFUNC(IOIQualifier_VERSUS_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_LIMIT", VALUEFUNC(IOIQualifier_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PORTFOLIO_SHOWN", VALUEFUNC(IOIQualifier_PORTFOLIO_SHOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_READY_TO_TRADE", VALUEFUNC(IOIQualifier_READY_TO_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PRE_OPEN", VALUEFUNC(IOIQualifier_PRE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_INDICATION", VALUEFUNC(IOIQualifier_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_MORE_BEHIND", VALUEFUNC(IOIQualifier_MORE_BEHIND_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_ATOPEN", VALUEFUNC(IOIQualifier_ATOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_VWAP", VALUEFUNC(IOIQualifier_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_PORTSHOW", VALUEFUNC(IOIQualifier_PORTSHOW_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIQualifier_AT_THE_CLOSE", VALUEFUNC(IOIQualifier_AT_THE_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY", VALUEFUNC(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(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(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(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(StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_CONVERSION", VALUEFUNC(MiscFeeType_CONVERSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_CONSUMPTION_TAX", VALUEFUNC(MiscFeeType_CONSUMPTION_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_LOCAL_COMMISSION", VALUEFUNC(MiscFeeType_LOCAL_COMMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_TAX", VALUEFUNC(MiscFeeType_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_LOCALCOMM", VALUEFUNC(MiscFeeType_LOCALCOMM_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_MARKUP", VALUEFUNC(MiscFeeType_MARKUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_SECURITY_LENDING", VALUEFUNC(MiscFeeType_SECURITY_LENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_PER_TRANSACTION", VALUEFUNC(MiscFeeType_PER_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_REGULATORY", VALUEFUNC(MiscFeeType_REGULATORY_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_EXCHFEE", VALUEFUNC(MiscFeeType_EXCHFEE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_CONSUMPTION", VALUEFUNC(MiscFeeType_CONSUMPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_STAMP", VALUEFUNC(MiscFeeType_STAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_TRANSFER_FEE", VALUEFUNC(MiscFeeType_TRANSFER_FEE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_AGENT", VALUEFUNC(MiscFeeType_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_OTHER", VALUEFUNC(MiscFeeType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_TRANSACTION", VALUEFUNC(MiscFeeType_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_REG", VALUEFUNC(MiscFeeType_REG_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_EXCHANGE_FEES", VALUEFUNC(MiscFeeType_EXCHANGE_FEES_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeType_LEVY", VALUEFUNC(MiscFeeType_LEVY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CLEARING_HOUSE", VALUEFUNC(SecurityIDSource_CLEARING_HOUSE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY", VALUEFUNC(SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_EXCHANGE_SYMBOL", VALUEFUNC(SecurityIDSource_EXCHANGE_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_SICOVAM", VALUEFUNC(SecurityIDSource_SICOVAM_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION", VALUEFUNC(SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISDA_FPML_PRODUCT_URL", VALUEFUNC(SecurityIDSource_ISDA_FPML_PRODUCT_URL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_RIC", VALUEFUNC(SecurityIDSource_RIC_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CLEARINGHOUSE", VALUEFUNC(SecurityIDSource_CLEARINGHOUSE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_FPML", VALUEFUNC(SecurityIDSource_FPML_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_RIC_CODE", VALUEFUNC(SecurityIDSource_RIC_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISOCURR", VALUEFUNC(SecurityIDSource_ISOCURR_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISO_CURRENCY_CODE", VALUEFUNC(SecurityIDSource_ISO_CURRENCY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_COMMON", VALUEFUNC(SecurityIDSource_COMMON_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_VALOREN", VALUEFUNC(SecurityIDSource_VALOREN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_BELGIAN", VALUEFUNC(SecurityIDSource_BELGIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CTA", VALUEFUNC(SecurityIDSource_CTA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISIN_NUMBER", VALUEFUNC(SecurityIDSource_ISIN_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISIN", VALUEFUNC(SecurityIDSource_ISIN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISOCOUNTRY", VALUEFUNC(SecurityIDSource_ISOCOUNTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_SEDOL", VALUEFUNC(SecurityIDSource_SEDOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_ISO_COUNTRY_CODE", VALUEFUNC(SecurityIDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_LETTER_OF_CREDIT", VALUEFUNC(SecurityIDSource_LETTER_OF_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_BLOOMBERG_SYMBOL", VALUEFUNC(SecurityIDSource_BLOOMBERG_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_BLMBRG", VALUEFUNC(SecurityIDSource_BLMBRG_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY", VALUEFUNC(SecurityIDSource_OPTIONPRICEREPORTINGAUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_WERTPAPIER", VALUEFUNC(SecurityIDSource_WERTPAPIER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER", VALUEFUNC(SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_EXCHSYMB", VALUEFUNC(SecurityIDSource_EXCHSYMB_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION", VALUEFUNC(SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_DUTCH", VALUEFUNC(SecurityIDSource_DUTCH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_QUIK", VALUEFUNC(SecurityIDSource_QUIK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityIDSource_CUSIP", VALUEFUNC(SecurityIDSource_CUSIP_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsRefType_OTHER_LANGUAGE", VALUEFUNC(NewsRefType_OTHER_LANGUAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsRefType_COMPLIMENTARY", VALUEFUNC(NewsRefType_COMPLIMENTARY_get), 0);
  rb_define_singleton_method(mQuickfix, "NewsRefType_REPLACEMENT", VALUEFUNC(NewsRefType_REPLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerOrderType_LIMIT", VALUEFUNC(TriggerOrderType_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TriggerOrderType_MARKET", VALUEFUNC(TriggerOrderType_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_AON", VALUEFUNC(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(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(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_CROSSAON", VALUEFUNC(CrossType_CROSSAON_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE", VALUEFUNC(CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_ONE_SIDE", VALUEFUNC(CrossType_CROSS_ONE_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_SAME_PRICE", VALUEFUNC(CrossType_CROSS_SAME_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSSSAMEPRICE", VALUEFUNC(CrossType_CROSSSAMEPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSS_IOC", VALUEFUNC(CrossType_CROSS_IOC_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSSIOC", VALUEFUNC(CrossType_CROSSIOC_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossType_CROSSONESIDE", VALUEFUNC(CrossType_CROSSONESIDE_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(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, "OpenCloseSettleFlag_SESSION_OPEN", VALUEFUNC(OpenCloseSettleFlag_SESSION_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_DAILY_OPEN", VALUEFUNC(OpenCloseSettleFlag_DAILY_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_EXPECTED_PRICE", VALUEFUNC(OpenCloseSettleFlag_EXPECTED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY", VALUEFUNC(OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE", VALUEFUNC(OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDBookType_PRICE_DEPTH", VALUEFUNC(MDBookType_PRICE_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDBookType_ORDER_DEPTH", VALUEFUNC(MDBookType_ORDER_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDBookType_TOP_OF_BOOK", VALUEFUNC(MDBookType_TOP_OF_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAPAFT", VALUEFUNC(BasisPxType_VWAPAFT_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI", VALUEFUNC(BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_MORNING_SESSION", VALUEFUNC(BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CLOSING_PRICE", VALUEFUNC(BasisPxType_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_DAY", VALUEFUNC(BasisPxType_VWAP_THROUGH_A_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION", VALUEFUNC(BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAPDAY", VALUEFUNC(BasisPxType_VWAPDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAPMORNXYORI", VALUEFUNC(BasisPxType_VWAPMORNXYORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAPMORN", VALUEFUNC(BasisPxType_VWAPMORN_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAPDAYXYORI", VALUEFUNC(BasisPxType_VWAPDAYXYORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_OTHERS", VALUEFUNC(BasisPxType_OTHERS_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_OPEN", VALUEFUNC(BasisPxType_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CURRPX", VALUEFUNC(BasisPxType_CURRPX_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAPAFTXYORI", VALUEFUNC(BasisPxType_VWAPAFTXYORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION", VALUEFUNC(BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CLSPXMORN", VALUEFUNC(BasisPxType_CLSPXMORN_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CURRENT_PRICE", VALUEFUNC(BasisPxType_CURRENT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_SQ", VALUEFUNC(BasisPxType_SQ_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_CLSPX", VALUEFUNC(BasisPxType_CLSPX_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_STRIKE", VALUEFUNC(BasisPxType_STRIKE_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI", VALUEFUNC(BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI", VALUEFUNC(BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_get), 0);
  rb_define_singleton_method(mQuickfix, "BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION", VALUEFUNC(BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_ROLLING_BARRIER", VALUEFUNC(ComplexEventType_ROLLING_BARRIER_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_UNDERLYING", VALUEFUNC(ComplexEventType_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KNOCK_OUT_UP", VALUEFUNC(ComplexEventType_KNOCK_OUT_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KNOCK_IN_UP", VALUEFUNC(ComplexEventType_KNOCK_IN_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KOCK_IN_DOWN", VALUEFUNC(ComplexEventType_KOCK_IN_DOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_TRIGGER", VALUEFUNC(ComplexEventType_TRIGGER_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_RESET_BARRIER", VALUEFUNC(ComplexEventType_RESET_BARRIER_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_CAPPED", VALUEFUNC(ComplexEventType_CAPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventType_KNOCK_OUT_DOWN", VALUEFUNC(ComplexEventType_KNOCK_OUT_DOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionResponse_REJECTED", VALUEFUNC(MassActionResponse_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "MassActionResponse_ACCEPTED", VALUEFUNC(MassActionResponse_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID", VALUEFUNC(SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_LIST_SECURITY_TYPES", VALUEFUNC(SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQSECIDPROV", VALUEFUNC(SecurityRequestType_REQSECIDPROV_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_LIST_SECURITIES", VALUEFUNC(SecurityRequestType_REQUEST_LIST_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQSECID", VALUEFUNC(SecurityRequestType_REQSECID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_SYMBOL", VALUEFUNC(SecurityRequestType_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE", VALUEFUNC(SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED", VALUEFUNC(SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQSECLIST", VALUEFUNC(SecurityRequestType_REQSECLIST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_TRADINGSESSIONID", VALUEFUNC(SecurityRequestType_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_PRODUCT", VALUEFUNC(SecurityRequestType_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_ALL_SECURITIES", VALUEFUNC(SecurityRequestType_ALL_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQSECLISTTYPES", VALUEFUNC(SecurityRequestType_REQSECLISTTYPES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS", VALUEFUNC(SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_EXCHANGE_CLOSED", VALUEFUNC(ListRejectReason_EXCHANGE_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_UNKNOWN_ORDER", VALUEFUNC(ListRejectReason_UNKNOWN_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC", VALUEFUNC(ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_DUPLICATE_ORDER", VALUEFUNC(ListRejectReason_DUPLICATE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(ListRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_OTHER", VALUEFUNC(ListRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "ListRejectReason_BROKER", VALUEFUNC(ListRejectReason_BROKER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_PROPRIETARY", VALUEFUNC(DeskType_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_ARBITRAGE", VALUEFUNC(DeskType_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_TRADING", VALUEFUNC(DeskType_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_DERIVATIVES", VALUEFUNC(DeskType_DERIVATIVES_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_SALES", VALUEFUNC(DeskType_SALES_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_INSTITUTIONAL", VALUEFUNC(DeskType_INSTITUTIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_INTERNATIONAL", VALUEFUNC(DeskType_INTERNATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_AGENCY", VALUEFUNC(DeskType_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_PREFERRED_TRADING", VALUEFUNC(DeskType_PREFERRED_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_OTHER", VALUEFUNC(DeskType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskType_PROGRAM_TRADING", VALUEFUNC(DeskType_PROGRAM_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T4", VALUEFUNC(SettlType_T4_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T5", VALUEFUNC(SettlType_T5_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_WHEN_AND_IF_ISSUED", VALUEFUNC(SettlType_WHEN_AND_IF_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_NEXTDAY", VALUEFUNC(SettlType_NEXTDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_FUTURE", VALUEFUNC(SettlType_FUTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_2", VALUEFUNC(SettlType_T_PLUS_2_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_SELLERS_OPTION", VALUEFUNC(SettlType_SELLERS_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_BROKEN_DATE", VALUEFUNC(SettlType_BROKEN_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_3", VALUEFUNC(SettlType_T_PLUS_3_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_4", VALUEFUNC(SettlType_T_PLUS_4_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_REGULAR", VALUEFUNC(SettlType_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_NEXT_DAY", VALUEFUNC(SettlType_NEXT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T_PLUS_5", VALUEFUNC(SettlType_T_PLUS_5_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_FX_SPOT_NEXT_SETTLEMENT", VALUEFUNC(SettlType_FX_SPOT_NEXT_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T1", VALUEFUNC(SettlType_T1_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_WHENISSUED", VALUEFUNC(SettlType_WHENISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T2", VALUEFUNC(SettlType_T2_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_T3", VALUEFUNC(SettlType_T3_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlType_CASH", VALUEFUNC(SettlType_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenClose_CLOSE", VALUEFUNC(OpenClose_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OpenClose_OPEN", VALUEFUNC(OpenClose_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ContractMultiplierUnit_SHARES", VALUEFUNC(ContractMultiplierUnit_SHARES_get), 0);
  rb_define_singleton_method(mQuickfix, "ContractMultiplierUnit_HOURS", VALUEFUNC(ContractMultiplierUnit_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "ContractMultiplierUnit_DAYS", VALUEFUNC(ContractMultiplierUnit_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE", VALUEFUNC(TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_LATE_TRADE", VALUEFUNC(TrdType_LATE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_FUTURES_LARGE_ORDER_EXECUTION", VALUEFUNC(TrdType_FUTURES_LARGE_ORDER_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES", VALUEFUNC(TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS", VALUEFUNC(TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCK_TRADE_38", VALUEFUNC(TrdType_BLOCK_TRADE_38_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_DELTA_NEUTRAL_TRANSACTION", VALUEFUNC(TrdType_DELTA_NEUTRAL_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_CASH_SETTLEMENT", VALUEFUNC(TrdType_CASH_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS", VALUEFUNC(TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_BONUS", VALUEFUNC(TrdType_SPECIAL_CUM_BONUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCK_TRADES", VALUEFUNC(TrdType_BLOCK_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_ALL_OR_NONE", VALUEFUNC(TrdType_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OPTION_EXERCISE", VALUEFUNC(TrdType_OPTION_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_FINANCING_TRANSACTION", VALUEFUNC(TrdType_FINANCING_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_TRANSFER", VALUEFUNC(TrdType_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_REGULAR_TRADE", VALUEFUNC(TrdType_REGULAR_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_TRADING_AT_SETTLEMENT", VALUEFUNC(TrdType_TRADING_AT_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_DIVIDEND", VALUEFUNC(TrdType_SPECIAL_EX_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_COUPON", VALUEFUNC(TrdType_SPECIAL_EX_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_PRICE", VALUEFUNC(TrdType_SPECIAL_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_RIGHTS", VALUEFUNC(TrdType_SPECIAL_CUM_RIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_BONUS", VALUEFUNC(TrdType_SPECIAL_EX_BONUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCKTRADE", VALUEFUNC(TrdType_BLOCKTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_GRANTED_TRADE", VALUEFUNC(TrdType_EXCHANGE_GRANTED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_BASIS_FACILITY", VALUEFUNC(TrdType_EXCHANGE_BASIS_FACILITY_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BLOCK_TRADE_1", VALUEFUNC(TrdType_BLOCK_TRADE_1_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_LATE_BUNCHED_TRADE", VALUEFUNC(TrdType_LATE_BUNCHED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_ERROR_TRADE", VALUEFUNC(TrdType_ERROR_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_NAME_CHANGE", VALUEFUNC(TrdType_NAME_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_LATEBUNCHEDTRADE", VALUEFUNC(TrdType_LATEBUNCHEDTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EFP", VALUEFUNC(TrdType_EFP_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_NON_STANDARD_SETTLEMENT", VALUEFUNC(TrdType_NON_STANDARD_SETTLEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PRIOR_REFERENCE_PRICE_TRADE", VALUEFUNC(TrdType_PRIOR_REFERENCE_PRICE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_FOR_RISK", VALUEFUNC(TrdType_EXCHANGE_FOR_RISK_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_FOR_SWAP", VALUEFUNC(TrdType_EXCHANGE_FOR_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_OF_FUTURES_FOR", VALUEFUNC(TrdType_EXCHANGE_OF_FUTURES_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OPTION_INTERIM_TRADE", VALUEFUNC(TrdType_OPTION_INTERIM_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PRIVATELY_NEGOTIATED_TRADES", VALUEFUNC(TrdType_PRIVATELY_NEGOTIATED_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS", VALUEFUNC(TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_DIVIDEND", VALUEFUNC(TrdType_SPECIAL_CUM_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_GUARANTEED_DELIVERY", VALUEFUNC(TrdType_GUARANTEED_DELIVERY_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PROROGATION_SELL", VALUEFUNC(TrdType_PROROGATION_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_WEIGHTEDAVERAGEPRICETRADE", VALUEFUNC(TrdType_WEIGHTEDAVERAGEPRICETRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PORTFOLIO_TRADE", VALUEFUNC(TrdType_PORTFOLIO_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_WEIGHTED_AVERAGE_PRICE_TRADE", VALUEFUNC(TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_WORKED_PRINCIPAL_TRADE", VALUEFUNC(TrdType_WORKED_PRINCIPAL_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PORTFOLIO_TRANSFER", VALUEFUNC(TrdType_PORTFOLIO_TRANSFER_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_T_TRADE", VALUEFUNC(TrdType_T_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS", VALUEFUNC(TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_CUM_COUPON", VALUEFUNC(TrdType_SPECIAL_CUM_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BUNCHEDTRADE", VALUEFUNC(TrdType_BUNCHEDTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_TTRADE", VALUEFUNC(TrdType_TTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OTC", VALUEFUNC(TrdType_OTC_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_AFTER_HOURS_TRADE", VALUEFUNC(TrdType_AFTER_HOURS_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PRIORREFERENCEPRICETRADE", VALUEFUNC(TrdType_PRIORREFERENCEPRICETRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_AFTERHOURSTRADE", VALUEFUNC(TrdType_AFTERHOURSTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_DERIVATIVE_RELATED_TRANSACTION", VALUEFUNC(TrdType_DERIVATIVE_RELATED_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_REPURCHASE_AGREEMENT", VALUEFUNC(TrdType_REPURCHASE_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_SPECIAL_EX_RIGHTS", VALUEFUNC(TrdType_SPECIAL_EX_RIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_PROROGATION_BUY", VALUEFUNC(TrdType_PROROGATION_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_BUNCHED_TRADE", VALUEFUNC(TrdType_BUNCHED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_OPTION_CABINET_TRADE", VALUEFUNC(TrdType_OPTION_CABINET_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_LATETRADE", VALUEFUNC(TrdType_LATETRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdType_REGULARTRADE", VALUEFUNC(TrdType_REGULARTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_MODIFIED_MOD_RESTRUCTURING", VALUEFUNC(RestructuringType_MODIFIED_MOD_RESTRUCTURING_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_FULL_RESTRUCTURING", VALUEFUNC(RestructuringType_FULL_RESTRUCTURING_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_NO_RESTRUCTURING_SPECIFIED", VALUEFUNC(RestructuringType_NO_RESTRUCTURING_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "RestructuringType_MODIFIED_RESTRUCTURING", VALUEFUNC(RestructuringType_MODIFIED_RESTRUCTURING_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_SELLSIDE", VALUEFUNC(ProgRptReqs_SELLSIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_REALTIME", VALUEFUNC(ProgRptReqs_REALTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_REAL_TIME_EXECUTION_REPORTS", VALUEFUNC(ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST", VALUEFUNC(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(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(ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_BUYSIDE", VALUEFUNC(ProgRptReqs_BUYSIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD", VALUEFUNC(ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_EVENING", VALUEFUNC(TradingSessionID_EVENING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_AFTER_HOURS", VALUEFUNC(TradingSessionID_AFTER_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_HALFDAY", VALUEFUNC(TradingSessionID_HALFDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_DAY", VALUEFUNC(TradingSessionID_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_MORNING", VALUEFUNC(TradingSessionID_MORNING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradingSessionID_AFTERNOON", VALUEFUNC(TradingSessionID_AFTERNOON_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_RECVFOREXEC", VALUEFUNC(ListOrderStatus_RECVFOREXEC_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_CXL", VALUEFUNC(ListOrderStatus_CXL_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_REJ", VALUEFUNC(ListOrderStatus_REJ_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_CANCELING", VALUEFUNC(ListOrderStatus_CANCELING_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_REJECT", VALUEFUNC(ListOrderStatus_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_ALL_DONE", VALUEFUNC(ListOrderStatus_ALL_DONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_INBIDPROC", VALUEFUNC(ListOrderStatus_INBIDPROC_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_ALLDONE", VALUEFUNC(ListOrderStatus_ALLDONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_IN_BIDDING_PROCESS", VALUEFUNC(ListOrderStatus_IN_BIDDING_PROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_RECEIVED_FOR_EXECUTION", VALUEFUNC(ListOrderStatus_RECEIVED_FOR_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_ALERT", VALUEFUNC(ListOrderStatus_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_RECEIVEDFOREXECUTION", VALUEFUNC(ListOrderStatus_RECEIVEDFOREXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_INBIDDINGPROCESS", VALUEFUNC(ListOrderStatus_INBIDDINGPROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_EXEC", VALUEFUNC(ListOrderStatus_EXEC_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_CANCELLING", VALUEFUNC(ListOrderStatus_CANCELLING_get), 0);
  rb_define_singleton_method(mQuickfix, "ListOrderStatus_EXECUTING", VALUEFUNC(ListOrderStatus_EXECUTING_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REJECT", VALUEFUNC(RegistStatus_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING", VALUEFUNC(RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REJECTED", VALUEFUNC(RegistStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_ACCEPTED", VALUEFUNC(RegistStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_REMINDER", VALUEFUNC(RegistStatus_REMINDER_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_HELD", VALUEFUNC(RegistStatus_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistStatus_ACCEPT", VALUEFUNC(RegistStatus_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE", VALUEFUNC(UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE", VALUEFUNC(UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_AVERAGE_VALUE", VALUEFUNC(UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingPriceDeterminationMethod_REGULAR", VALUEFUNC(UnderlyingPriceDeterminationMethod_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CXLORDERSSECURITYTYPE", VALUEFUNC(MassCancelRequestType_CXLORDERSSECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY", VALUEFUNC(MassCancelRequestType_CXLORDERSUNDERLYINGSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CXLORDERSTRDSESSION", VALUEFUNC(MassCancelRequestType_CXLORDERSTRDSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CXLALLORDERS", VALUEFUNC(MassCancelRequestType_CXLALLORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CXLORDERSSECURITY", VALUEFUNC(MassCancelRequestType_CXLORDERSSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CXLORDERSPRODUCT", VALUEFUNC(MassCancelRequestType_CXLORDERSPRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ALL_ORDERS", VALUEFUNC(MassCancelRequestType_CANCEL_ALL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER", VALUEFUNC(MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CXLORDERSCFICODE", VALUEFUNC(MassCancelRequestType_CXLORDERSCFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE", VALUEFUNC(MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID", VALUEFUNC(DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_UNDELYINGSYMBOL", VALUEFUNC(DerivativeSecurityListRequestType_UNDELYINGSYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_UNDERLYING_PRODUCT", VALUEFUNC(DerivativeSecurityListRequestType_UNDERLYING_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE", VALUEFUNC(DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE", VALUEFUNC(DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_SYMBOL", VALUEFUNC(DerivativeSecurityListRequestType_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_TRADINGSESSIONID", VALUEFUNC(DerivativeSecurityListRequestType_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_ALL_SECURITIES", VALUEFUNC(DerivativeSecurityListRequestType_ALL_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "DerivativeSecurityListRequestType_PRODUCT", VALUEFUNC(DerivativeSecurityListRequestType_PRODUCT_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejResponseTo_ORDCXLREPREQ", VALUEFUNC(CxlRejResponseTo_ORDCXLREPREQ_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejResponseTo_ORDER_CANCEL_REQUEST", VALUEFUNC(CxlRejResponseTo_ORDER_CANCEL_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST", VALUEFUNC(CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlRejResponseTo_ORDCXLREQ", VALUEFUNC(CxlRejResponseTo_ORDCXLREQ_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_BY_QUOTETYPE", VALUEFUNC(QuoteCancelType_CANCEL_BY_QUOTETYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES", VALUEFUNC(QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID", VALUEFUNC(QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL", VALUEFUNC(QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CXLUNDER", VALUEFUNC(QuoteCancelType_CXLUNDER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_ALL_QUOTES", VALUEFUNC(QuoteCancelType_CANCEL_ALL_QUOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CXLSYM", VALUEFUNC(QuoteCancelType_CXLSYM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY", VALUEFUNC(QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY", VALUEFUNC(QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER", VALUEFUNC(QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CXLSECTYPE", VALUEFUNC(QuoteCancelType_CXLSECTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_ALL_QUOTES", VALUEFUNC(QuoteCancelType_CANCEL_FOR_ALL_QUOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CXLALL", VALUEFUNC(QuoteCancelType_CXLALL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_SECURITY_TYPE", VALUEFUNC(QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCancelType_CANCEL_FOR_SYMBOL", VALUEFUNC(QuoteCancelType_CANCEL_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_PER_LOT", VALUEFUNC(StipulationType_POOLS_PER_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUM_LOAN_BALANCE", VALUEFUNC(StipulationType_MAXIMUM_LOAN_BALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANTPREPAYMENTYIELD", VALUEFUNC(StipulationType_CONSTANTPREPAYMENTYIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CUSTOM_START_END_DATE", VALUEFUNC(StipulationType_CUSTOM_START_END_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CALL_PROTECTION", VALUEFUNC(StipulationType_CALL_PROTECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITYYEARANDMONTH", VALUEFUNC(StipulationType_MATURITYYEARANDMONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE", VALUEFUNC(StipulationType_FINALCPROFHOMEEQUITYPREPAYMENTCURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITYRANGE", VALUEFUNC(StipulationType_MATURITYRANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_COUPON_RANGE", VALUEFUNC(StipulationType_COUPON_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENTOFBMAPREPAYMENTCURVE", VALUEFUNC(StipulationType_PERCENTOFBMAPREPAYMENTCURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SUBSTITUTIONSLEFTREPO", VALUEFUNC(StipulationType_SUBSTITUTIONSLEFTREPO_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_LOOKBACKDAYS", VALUEFUNC(StipulationType_LOOKBACKDAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CALLPROTECTION", VALUEFUNC(StipulationType_CALLPROTECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUMSUBSTITUTIONSREPO", VALUEFUNC(StipulationType_MAXIMUMSUBSTITUTIONSREPO_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YEARORYEARMONTHOFISSUE", VALUEFUNC(StipulationType_YEARORYEARMONTHOFISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANTPREPAYMENTRATE", VALUEFUNC(StipulationType_CONSTANTPREPAYMENTRATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISSUE_SIZE_RANGE", VALUEFUNC(StipulationType_ISSUE_SIZE_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTEDAVERAGEMATURITY", VALUEFUNC(StipulationType_WEIGHTEDAVERAGEMATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANT_PREPAYMENT_RATE", VALUEFUNC(StipulationType_CONSTANT_PREPAYMENT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE", VALUEFUNC(StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLSMINIMUM", VALUEFUNC(StipulationType_POOLSMINIMUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE", VALUEFUNC(StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BROKERS_SALES_CREDIT", VALUEFUNC(StipulationType_BROKERS_SALES_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ORDER_QUANTITY_INCREMENT", VALUEFUNC(StipulationType_ORDER_QUANTITY_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE", VALUEFUNC(StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET", VALUEFUNC(StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISSUERS_TICKER", VALUEFUNC(StipulationType_ISSUERS_TICKER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISOCURRENCYCODE", VALUEFUNC(StipulationType_ISOCURRENCYCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY", VALUEFUNC(StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_DISCOUNT_RATE", VALUEFUNC(StipulationType_DISCOUNT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_VALUATIONDISCOUNT", VALUEFUNC(StipulationType_VALUATIONDISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SINGLE_MONTHLY_MORTALITY", VALUEFUNC(StipulationType_SINGLE_MONTHLY_MORTALITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_LOT_VARIANCE", VALUEFUNC(StipulationType_LOT_VARIANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE", VALUEFUNC(StipulationType_PERCENTOFMANUFACTUREDHOUSINGPREPAYMENTCURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_FREEFORMTEXT", VALUEFUNC(StipulationType_FREEFORMTEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WHOLE_POOL", VALUEFUNC(StipulationType_WHOLE_POOL_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_GEOGRAPHICS_AND_RANGE", VALUEFUNC(StipulationType_GEOGRAPHICS_AND_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE", VALUEFUNC(StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED", VALUEFUNC(StipulationType_TRADEVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_FREEFORM_TEXT", VALUEFUNC(StipulationType_FREEFORM_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_RATING_SOURCE_AND_RANGE", VALUEFUNC(StipulationType_RATING_SOURCE_AND_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS", VALUEFUNC(StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS", VALUEFUNC(StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_NUMBER_OF_PIECES", VALUEFUNC(StipulationType_NUMBER_OF_PIECES_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUM_INCREMENT", VALUEFUNC(StipulationType_MINIMUM_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRODUCTIONYEAR", VALUEFUNC(StipulationType_PRODUCTIONYEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_MATURITY", VALUEFUNC(StipulationType_WEIGHTED_AVERAGE_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_GEOGRAPHICS", VALUEFUNC(StipulationType_GEOGRAPHICS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUMQUANTITY", VALUEFUNC(StipulationType_MINIMUMQUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOL_IDENTIFIER", VALUEFUNC(StipulationType_POOL_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITY_YEAR_AND_MONTH", VALUEFUNC(StipulationType_MATURITY_YEAR_AND_MONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRICINGFREQUENCY", VALUEFUNC(StipulationType_PRICINGFREQUENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED", VALUEFUNC(StipulationType_SECURITYTYPEINCLUDEDOREXCLUDED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_EXPLICITLOTIDENTIFIER", VALUEFUNC(StipulationType_EXPLICITLOTIDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUM_SUBSTITUTIONS", VALUEFUNC(StipulationType_MAXIMUM_SUBSTITUTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR", VALUEFUNC(StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTEDAVERAGELOANAGE", VALUEFUNC(StipulationType_WEIGHTEDAVERAGELOANAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BENCHMARK_PRICE_SOURCE", VALUEFUNC(StipulationType_BENCHMARK_PRICE_SOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUMDENOMINATION", VALUEFUNC(StipulationType_MINIMUMDENOMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE", VALUEFUNC(StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PAYMENTFREQUENCYCALENDAR", VALUEFUNC(StipulationType_PAYMENTFREQUENCYCALENDAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_MAXIMUM", VALUEFUNC(StipulationType_POOLS_MAXIMUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SUBSTITUTIONS_FREQUENCY", VALUEFUNC(StipulationType_SUBSTITUTIONS_FREQUENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BENCHMARKPRICESOURCE", VALUEFUNC(StipulationType_BENCHMARKPRICESOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ABSOLUTEPREPAYMENTSPEED", VALUEFUNC(StipulationType_ABSOLUTEPREPAYMENTSPEED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BANKQUALIFIED", VALUEFUNC(StipulationType_BANKQUALIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YIELDRANGE", VALUEFUNC(StipulationType_YIELDRANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BARGAINCONDITIONS", VALUEFUNC(StipulationType_BARGAINCONDITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MONTHLYPREPAYMENTRATE", VALUEFUNC(StipulationType_MONTHLYPREPAYMENTRATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLSPERLOT", VALUEFUNC(StipulationType_POOLSPERLOT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANT_PREPAYMENT_YIELD", VALUEFUNC(StipulationType_CONSTANT_PREPAYMENT_YIELD_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUM_DENOMINATION", VALUEFUNC(StipulationType_MINIMUM_DENOMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ALTERNATIVE_MINIMUM_TAX", VALUEFUNC(StipulationType_ALTERNATIVE_MINIMUM_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CUSTOMSTARTENDDATE", VALUEFUNC(StipulationType_CUSTOMSTARTENDDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TYPEOFREDEMPTIONVALUESARE", VALUEFUNC(StipulationType_TYPEOFREDEMPTIONVALUESARE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE", VALUEFUNC(StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_NUMBEROFPIECES", VALUEFUNC(StipulationType_NUMBEROFPIECES_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AMT", VALUEFUNC(StipulationType_AMT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANTPREPAYMENTPENALTY", VALUEFUNC(StipulationType_CONSTANTPREPAYMENTPENALTY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUM_ORDER_SIZE", VALUEFUNC(StipulationType_MAXIMUM_ORDER_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AUTOREINVESTMENTATRATEORBETTER", VALUEFUNC(StipulationType_AUTOREINVESTMENTATRATEORBETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BARGAIN_CONDITIONS", VALUEFUNC(StipulationType_BARGAIN_CONDITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_GEOGRAPHICSANDRANGE", VALUEFUNC(StipulationType_GEOGRAPHICSANDRANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED", VALUEFUNC(StipulationType_LOTVARIANCEVALUEINPERCENTMAXIMUMOVERORUNDERALLOCATIONALLOWED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TYPE_OF_ROLL_TRADE", VALUEFUNC(StipulationType_TYPE_OF_ROLL_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE", VALUEFUNC(StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE", VALUEFUNC(StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_COUPON", VALUEFUNC(StipulationType_WEIGHTED_AVERAGE_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER", VALUEFUNC(StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_STRUCTURE", VALUEFUNC(StipulationType_STRUCTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WHOLEPOOL", VALUEFUNC(StipulationType_WHOLEPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MARKET_SECTOR", VALUEFUNC(StipulationType_MARKET_SECTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITY_RANGE", VALUEFUNC(StipulationType_MATURITY_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED", VALUEFUNC(StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLSPERMILLION", VALUEFUNC(StipulationType_POOLSPERMILLION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TRADE_VARIANCE", VALUEFUNC(StipulationType_TRADE_VARIANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISSUERSTICKER", VALUEFUNC(StipulationType_ISSUERSTICKER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRICERANGE", VALUEFUNC(StipulationType_PRICERANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_LOOKBACK_DAYS", VALUEFUNC(StipulationType_LOOKBACK_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE", VALUEFUNC(StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_PER_MILLION", VALUEFUNC(StipulationType_POOLS_PER_MILLION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUMINCREMENT", VALUEFUNC(StipulationType_MINIMUMINCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MATURITY_YEAR", VALUEFUNC(StipulationType_MATURITY_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_RATINGSOURCEANDRANGE", VALUEFUNC(StipulationType_RATINGSOURCEANDRANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AVERAGE_LOAN_SIZE", VALUEFUNC(StipulationType_AVERAGE_LOAN_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PURPOSE", VALUEFUNC(StipulationType_PURPOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISO_CURRENCY_CODE", VALUEFUNC(StipulationType_ISO_CURRENCY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_RESTRICTED", VALUEFUNC(StipulationType_RESTRICTED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BROKER_SALES_CREDIT_OVERRIDE", VALUEFUNC(StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON", VALUEFUNC(StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTEDAVERAGECOUPON", VALUEFUNC(StipulationType_WEIGHTEDAVERAGECOUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE", VALUEFUNC(StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ISSUESIZERANGE", VALUEFUNC(StipulationType_ISSUESIZERANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YEAR_OF_ISSUE", VALUEFUNC(StipulationType_YEAR_OF_ISSUE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTEDAVERAGELIFECOUPON", VALUEFUNC(StipulationType_WEIGHTEDAVERAGELIFECOUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PAYMENT_FREQUENCY_CALENDAR", VALUEFUNC(StipulationType_PAYMENT_FREQUENCY_CALENDAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TRADERS_CREDIT", VALUEFUNC(StipulationType_TRADERS_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MINIMUM_QUANTITY", VALUEFUNC(StipulationType_MINIMUM_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SUBSTITUTIONS_LEFT", VALUEFUNC(StipulationType_SUBSTITUTIONS_LEFT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLS_PER_TRADE", VALUEFUNC(StipulationType_POOLS_PER_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_TYPE_OF_REDEMPTION", VALUEFUNC(StipulationType_TYPE_OF_REDEMPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_CONSTANT_PREPAYMENT_PENALTY", VALUEFUNC(StipulationType_CONSTANT_PREPAYMENT_PENALTY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LOAN_AGE", VALUEFUNC(StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRICE_RANGE", VALUEFUNC(StipulationType_PRICE_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SUBSTITUTIONSFREQUENCYREPO", VALUEFUNC(StipulationType_SUBSTITUTIONSFREQUENCYREPO_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRODUCTION_YEAR", VALUEFUNC(StipulationType_PRODUCTION_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_SINGLEMONTHLYMORTALITY", VALUEFUNC(StipulationType_SINGLEMONTHLYMORTALITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_OF_BMA_PREPAYMENT_CURVE", VALUEFUNC(StipulationType_OF_BMA_PREPAYMENT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_EXPLICIT_LOT_IDENTIFIER", VALUEFUNC(StipulationType_EXPLICIT_LOT_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_ABSOLUTE_PREPAYMENT_SPEED", VALUEFUNC(StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MAXIMUMDENOMINATION", VALUEFUNC(StipulationType_MAXIMUMDENOMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE", VALUEFUNC(StipulationType_PERCENTOFPROSPECTUSPREPAYMENTCURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_VALUATION_DISCOUNT", VALUEFUNC(StipulationType_VALUATION_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YIELD_TO_MATURITY", VALUEFUNC(StipulationType_YIELD_TO_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_WEIGHTED_AVERAGE_LIFE", VALUEFUNC(StipulationType_WEIGHTED_AVERAGE_LIFE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLSMAXIMUM", VALUEFUNC(StipulationType_POOLSMAXIMUM_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_YIELD_RANGE", VALUEFUNC(StipulationType_YIELD_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_PRICING_FREQUENCY", VALUEFUNC(StipulationType_PRICING_FREQUENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_POOLSPERTRADE", VALUEFUNC(StipulationType_POOLSPERTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MONTHLY_PREPAYMENT_RATE", VALUEFUNC(StipulationType_MONTHLY_PREPAYMENT_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_COUPONRANGE", VALUEFUNC(StipulationType_COUPONRANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_MARKETSECTOR", VALUEFUNC(StipulationType_MARKETSECTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_AVERAGE_FICO_SCORE", VALUEFUNC(StipulationType_AVERAGE_FICO_SCORE_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_INSURED", VALUEFUNC(StipulationType_INSURED_get), 0);
  rb_define_singleton_method(mQuickfix, "StipulationType_BANK_QUALIFIED", VALUEFUNC(StipulationType_BANK_QUALIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_STANDARD", VALUEFUNC(PriceQuoteMethod_STANDARD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_PERCENT_OF_PAR", VALUEFUNC(PriceQuoteMethod_PERCENT_OF_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_INDEX", VALUEFUNC(PriceQuoteMethod_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceQuoteMethod_INTEREST_RATE_INDEX", VALUEFUNC(PriceQuoteMethod_INTEREST_RATE_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REQUIREDTAGMISSING", VALUEFUNC(SessionRejectReason_REQUIREDTAGMISSING_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER", VALUEFUNC(SessionRejectReason_TAGSPECIFIEDOUTOFREQUIREDORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER", VALUEFUNC(SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALIDTAGNUMBER", VALUEFUNC(SessionRejectReason_INVALIDTAGNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG", VALUEFUNC(SessionRejectReason_VALUEISINCORRECTOUTOFRANGEFORTHISTAG_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_COMPID_PROBLEM", VALUEFUNC(SessionRejectReason_COMPID_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SENDINGTIMEACCURACYPROBLEM", VALUEFUNC(SessionRejectReason_SENDINGTIMEACCURACYPROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SIGNATURE_PROBLEM", VALUEFUNC(SessionRejectReason_SIGNATURE_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE", VALUEFUNC(SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_UNDEFINEDTAG", VALUEFUNC(SessionRejectReason_UNDEFINEDTAG_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_XML_VALIDATION_ERROR", VALUEFUNC(SessionRejectReason_XML_VALIDATION_ERROR_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER", VALUEFUNC(SessionRejectReason_NONDATAVALUEINCLUDESFIELDDELIMITERSOHCHARACTER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_UNDEFINED_TAG", VALUEFUNC(SessionRejectReason_UNDEFINED_TAG_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAGAPPEARSMORETHANONCE", VALUEFUNC(SessionRejectReason_TAGAPPEARSMORETHANONCE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE", VALUEFUNC(SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER", VALUEFUNC(SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REQUIRED_TAG_MISSING", VALUEFUNC(SessionRejectReason_REQUIRED_TAG_MISSING_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALIDMSGTYPE", VALUEFUNC(SessionRejectReason_INVALIDMSGTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_XMLVALIDATIONERROR", VALUEFUNC(SessionRejectReason_XMLVALIDATIONERROR_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER", VALUEFUNC(SessionRejectReason_REPEATINGGROUPFIELDSOUTOFORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP", VALUEFUNC(SessionRejectReason_INCORRECTNUMINGROUPCOUNTFORREPEATINGGROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE", VALUEFUNC(SessionRejectReason_TAGSPECIFIEDWITHOUTAVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_DECRYPTIONPROBLEM", VALUEFUNC(SessionRejectReason_DECRYPTIONPROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECTDATAFORMATFORVALUE", VALUEFUNC(SessionRejectReason_INCORRECTDATAFORMATFORVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_OTHER", VALUEFUNC(SessionRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP", VALUEFUNC(SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE", VALUEFUNC(SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_COMPIDPROBLEM", VALUEFUNC(SessionRejectReason_COMPIDPROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER", VALUEFUNC(SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SIGNATUREPROBLEM", VALUEFUNC(SessionRejectReason_SIGNATUREPROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_DECRYPTION_PROBLEM", VALUEFUNC(SessionRejectReason_DECRYPTION_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_TAG_NUMBER", VALUEFUNC(SessionRejectReason_INVALID_TAG_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE", VALUEFUNC(SessionRejectReason_TAGNOTDEFINEDFORTHISMESSAGETYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_VALUE_IS_INCORRECT", VALUEFUNC(SessionRejectReason_VALUE_IS_INCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE", VALUEFUNC(SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_INVALID_MSGTYPE", VALUEFUNC(SessionRejectReason_INVALID_MSGTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM", VALUEFUNC(SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_TRI_PARTY", VALUEFUNC(DeliveryType_TRI_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_HOLD_IN_CUSTODY", VALUEFUNC(DeliveryType_HOLD_IN_CUSTODY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_FREE", VALUEFUNC(DeliveryType_FREE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_HOLDINCUSTODY", VALUEFUNC(DeliveryType_HOLDINCUSTODY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_VERSUSPAYMENT", VALUEFUNC(DeliveryType_VERSUSPAYMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_VERSUS_PAYMENT_DELIVER", VALUEFUNC(DeliveryType_VERSUS_PAYMENT_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_FREE_DELIVER", VALUEFUNC(DeliveryType_FREE_DELIVER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeliveryType_TRIPARTY", VALUEFUNC(DeliveryType_TRIPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_LOCAL", VALUEFUNC(Scope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_LOCAL_MARKET", VALUEFUNC(Scope_LOCAL_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_GLOBAL", VALUEFUNC(Scope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_NATIONAL", VALUEFUNC(Scope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Scope_LOCALMARKET", VALUEFUNC(Scope_LOCALMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "DeleteReason_CANCELLATION", VALUEFUNC(DeleteReason_CANCELLATION_get), 0);
  rb_define_singleton_method(mQuickfix, "DeleteReason_CANCELTRADEBUST", VALUEFUNC(DeleteReason_CANCELTRADEBUST_get), 0);
  rb_define_singleton_method(mQuickfix, "DeleteReason_CANCELATION", VALUEFUNC(DeleteReason_CANCELATION_get), 0);
  rb_define_singleton_method(mQuickfix, "DeleteReason_ERROR", VALUEFUNC(DeleteReason_ERROR_get), 0);
  rb_define_singleton_method(mQuickfix, "InViewOfCommon_NO", VALUEFUNC(InViewOfCommon_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "InViewOfCommon_YES", VALUEFUNC(InViewOfCommon_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "NoSides_BOTHSIDES", VALUEFUNC(NoSides_BOTHSIDES_get), 0);
  rb_define_singleton_method(mQuickfix, "NoSides_ONESIDE", VALUEFUNC(NoSides_ONESIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "NoSides_ONE_SIDE", VALUEFUNC(NoSides_ONE_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "NoSides_BOTH_SIDES", VALUEFUNC(NoSides_BOTH_SIDES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TERM_LIQUIDITY_NOTE", VALUEFUNC(SecurityType_TERM_LIQUIDITY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TO_BE_ANNOUNCED", VALUEFUNC(SecurityType_TO_BE_ANNOUNCED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVERSE_REPURCHASE_AGREEMENT", VALUEFUNC(SecurityType_REVERSE_REPURCHASE_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BRADY_BOND", VALUEFUNC(SecurityType_BRADY_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES", VALUEFUNC(SecurityType_TREASURYINFLATIONPROTECTEDSECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORP_MORTGAGE_BACKED_SECURITIES", VALUEFUNC(SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATE_OF_PARTICIPATION", VALUEFUNC(SecurityType_CERTIFICATE_OF_PARTICIPATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BUY_SELLBACK", VALUEFUNC(SecurityType_BUY_SELLBACK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTIONS_ON_COMBO", VALUEFUNC(SecurityType_OPTIONS_ON_COMBO_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MULTILEG_INSTRUMENT", VALUEFUNC(SecurityType_MULTILEG_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_ALLOCATION", VALUEFUNC(SecurityType_TAX_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_NOTE_BOND", VALUEFUNC(SecurityType_US_TREASURY_NOTE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVENUE_ANTICIPATION_NOTE", VALUEFUNC(SecurityType_REVENUE_ANTICIPATION_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_YANKEECERTIFICATEOFDEPOSIT", VALUEFUNC(SecurityType_YANKEECERTIFICATEOFDEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MEDIUMTERMNOTES", VALUEFUNC(SecurityType_MEDIUMTERMNOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIAL_TAX", VALUEFUNC(SecurityType_SPECIAL_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRIVATE_EXPORT_FUNDING", VALUEFUNC(SecurityType_PRIVATE_EXPORT_FUNDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EUROCERTIFICATEOFDEPOSIT", VALUEFUNC(SecurityType_EUROCERTIFICATEOFDEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIAL_OBLIGATION", VALUEFUNC(SecurityType_SPECIAL_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FX_SWAP", VALUEFUNC(SecurityType_FX_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVOLVER_TERM_LOAN", VALUEFUNC(SecurityType_REVOLVER_TERM_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAXEXEMPTCOMMERCIALPAPER", VALUEFUNC(SecurityType_TAXEXEMPTCOMMERCIALPAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVOLVER_LOAN", VALUEFUNC(SecurityType_REVOLVER_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CASH", VALUEFUNC(SecurityType_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE", VALUEFUNC(SecurityType_USTREASURYNOTEDEPRECATEDVALUEUSETNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MISCELLANEOUS_PASS_THRU", VALUEFUNC(SecurityType_MISCELLANEOUS_PASS_THRU_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CONVERTIBLEBOND", VALUEFUNC(SecurityType_CONVERTIBLEBOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_VARIABLE_RATE_DEMAND_NOTE", VALUEFUNC(SecurityType_VARIABLE_RATE_DEMAND_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MULTILEGINSTRUMENT", VALUEFUNC(SecurityType_MULTILEGINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE", VALUEFUNC(SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIALOBLIGATION", VALUEFUNC(SecurityType_SPECIALOBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_TREASURY_BILLS", VALUEFUNC(SecurityType_CANADIAN_TREASURY_BILLS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVENUEANTICIPATIONNOTE", VALUEFUNC(SecurityType_REVENUEANTICIPATIONNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATEOFOBLIGATION", VALUEFUNC(SecurityType_CERTIFICATEOFOBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INDEXEDLINKED", VALUEFUNC(SecurityType_INDEXEDLINKED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_LETTER_OF_CREDIT", VALUEFUNC(SecurityType_LETTER_OF_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MANDATORYTENDER", VALUEFUNC(SecurityType_MANDATORYTENDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USTREASURYBOND", VALUEFUNC(SecurityType_USTREASURYBOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TERMLOAN", VALUEFUNC(SecurityType_TERMLOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTIONS_ON_FUTURES", VALUEFUNC(SecurityType_OPTIONS_ON_FUTURES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PROMISSORYNOTE", VALUEFUNC(SecurityType_PROMISSORYNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DUAL_CURRENCY", VALUEFUNC(SecurityType_DUAL_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WILDCARD_ENTRY", VALUEFUNC(SecurityType_WILDCARD_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANK_DEPOSITORY_NOTE", VALUEFUNC(SecurityType_BANK_DEPOSITORY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REPLACED", VALUEFUNC(SecurityType_REPLACED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_PRINCIPAL_ONLY", VALUEFUNC(SecurityType_MORTGAGE_PRINCIPAL_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_TREASURY_NOTES", VALUEFUNC(SecurityType_CANADIAN_TREASURY_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL", VALUEFUNC(SecurityType_USTREASURYBILLDEPRECATEDVALUEUSETBILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TOBEANNOUNCED", VALUEFUNC(SecurityType_TOBEANNOUNCED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURITIES_PLEDGE", VALUEFUNC(SecurityType_SECURITIES_PLEDGE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_YANKEE_CORPORATE_BOND", VALUEFUNC(SecurityType_YANKEE_CORPORATE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FX_SPOT", VALUEFUNC(SecurityType_FX_SPOT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_LIQUIDITYNOTE", VALUEFUNC(SecurityType_LIQUIDITYNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OVERNIGHT", VALUEFUNC(SecurityType_OVERNIGHT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_INTEREST_ONLY", VALUEFUNC(SecurityType_MORTGAGE_INTEREST_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BRIDGELOAN", VALUEFUNC(SecurityType_BRIDGELOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC", VALUEFUNC(SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EXTENDED_COMM_NOTE", VALUEFUNC(SecurityType_EXTENDED_COMM_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATEOFPARTICIPATION", VALUEFUNC(SecurityType_CERTIFICATEOFPARTICIPATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CATS_TIGERS_LIONS", VALUEFUNC(SecurityType_CATS_TIGERS_LIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FORWARD", VALUEFUNC(SecurityType_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT", VALUEFUNC(SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PREFERRED_STOCK", VALUEFUNC(SecurityType_PREFERRED_STOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BOND", VALUEFUNC(SecurityType_US_TREASURY_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES", VALUEFUNC(SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BUYSELLBACK", VALUEFUNC(SecurityType_BUYSELLBACK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTIONS_ON_PHYSICAL", VALUEFUNC(SecurityType_OPTIONS_ON_PHYSICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_ASSETBACKEDSECURITIES", VALUEFUNC(SecurityType_ASSETBACKEDSECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_NON_DELIVERABLE_FORWARD", VALUEFUNC(SecurityType_NON_DELIVERABLE_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_PRINCIPLE_ONLY", VALUEFUNC(SecurityType_MORTGAGE_PRINCIPLE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_IOETTE", VALUEFUNC(SecurityType_MORTGAGE_IOETTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USD_SUPRANATIONAL_COUPONS", VALUEFUNC(SecurityType_USD_SUPRANATIONAL_COUPONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WARRANT", VALUEFUNC(SecurityType_WARRANT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FOREIGN_EXCHANGE_CONTRACT", VALUEFUNC(SecurityType_FOREIGN_EXCHANGE_CONTRACT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FOREIGNEXCHANGECONTRACT", VALUEFUNC(SecurityType_FOREIGNEXCHANGECONTRACT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES", VALUEFUNC(SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIAL_ASSESSMENT", VALUEFUNC(SecurityType_SPECIAL_ASSESSMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EUROSUPRANATIONALCOUPONS", VALUEFUNC(SecurityType_EUROSUPRANATIONALCOUPONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEBTOR_IN_POSSESSION", VALUEFUNC(SecurityType_DEBTOR_IN_POSSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_MONEY_MARKETS", VALUEFUNC(SecurityType_CANADIAN_MONEY_MARKETS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGEPRINCIPALONLY", VALUEFUNC(SecurityType_MORTGAGEPRINCIPALONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USTREASURYNOTE", VALUEFUNC(SecurityType_USTREASURYNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEBTORINPOSSESSION", VALUEFUNC(SecurityType_DEBTORINPOSSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVENUEBONDS", VALUEFUNC(SecurityType_REVENUEBONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGEINTERESTONLY", VALUEFUNC(SecurityType_MORTGAGEINTERESTONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEPOSITNOTES", VALUEFUNC(SecurityType_DEPOSITNOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE", VALUEFUNC(SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGEPRIVATEPLACEMENT", VALUEFUNC(SecurityType_MORTGAGEPRIVATEPLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_NO_SECURITY_TYPE", VALUEFUNC(SecurityType_NO_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIALASSESSMENT", VALUEFUNC(SecurityType_SPECIALASSESSMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_LETTEROFCREDIT", VALUEFUNC(SecurityType_LETTEROFCREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAXALLOCATION", VALUEFUNC(SecurityType_TAXALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAXABLE_MUNICIPAL_CP", VALUEFUNC(SecurityType_TAXABLE_MUNICIPAL_CP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OPTION", VALUEFUNC(SecurityType_OPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_NOSECURITYTYPE", VALUEFUNC(SecurityType_NOSECURITYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PROMISSORY_NOTE", VALUEFUNC(SecurityType_PROMISSORY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION", VALUEFUNC(SecurityType_COLLATERALIZEDMORTGAGEOBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DUALCURRENCY", VALUEFUNC(SecurityType_DUALCURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CREDIT_DEFAULT_SWAP", VALUEFUNC(SecurityType_CREDIT_DEFAULT_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAXANTICIPATIONNOTE", VALUEFUNC(SecurityType_TAXANTICIPATIONNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_PRIVATE_PLACEMENT", VALUEFUNC(SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_GENERAL_OBLIGATION_BONDS", VALUEFUNC(SecurityType_GENERAL_OBLIGATION_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SHORTTERMLOANNOTE", VALUEFUNC(SecurityType_SHORTTERMLOANNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COMMERCIAL_PAPER", VALUEFUNC(SecurityType_COMMERCIAL_PAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGE_BACKED_SECURITIES", VALUEFUNC(SecurityType_MORTGAGE_BACKED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_SOVEREIGNS", VALUEFUNC(SecurityType_EURO_SOVEREIGNS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_REVENUE_ANTICIPATION_NOTE", VALUEFUNC(SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PFANDBRIEFE", VALUEFUNC(SecurityType_PFANDBRIEFE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OTHER_ANTICIPATION_NOTES", VALUEFUNC(SecurityType_OTHER_ANTICIPATION_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER", VALUEFUNC(SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRIVATEEXPORTFUNDING", VALUEFUNC(SecurityType_PRIVATEEXPORTFUNDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_OTHERANTICIPATIONNOTESBANGANETC", VALUEFUNC(SecurityType_OTHERANTICIPATIONNOTESBANGANETC_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAX_ANTICIPATION_NOTE", VALUEFUNC(SecurityType_TAX_ANTICIPATION_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TREASURY_BILL", VALUEFUNC(SecurityType_TREASURY_BILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PLAZOS_FIJOS", VALUEFUNC(SecurityType_PLAZOS_FIJOS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_COMMERCIAL_PAPER", VALUEFUNC(SecurityType_EURO_COMMERCIAL_PAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MANDATORY_TENDER", VALUEFUNC(SecurityType_MANDATORY_TENDER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION", VALUEFUNC(SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PREFERREDSTOCK", VALUEFUNC(SecurityType_PREFERREDSTOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_VARIABLERATEDEMANDNOTE", VALUEFUNC(SecurityType_VARIABLERATEDEMANDNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEFAULTED", VALUEFUNC(SecurityType_DEFAULTED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INDEXED_LINKED", VALUEFUNC(SecurityType_INDEXED_LINKED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_IOETTE_MORTGAGE", VALUEFUNC(SecurityType_IOETTE_MORTGAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATE_OF_DEPOSIT", VALUEFUNC(SecurityType_CERTIFICATE_OF_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BILLOFEXCHANGES", VALUEFUNC(SecurityType_BILLOFEXCHANGES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE", VALUEFUNC(SecurityType_PRINCIPALSTRIPOFACALLABLEBONDORNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EUROSOVEREIGNS", VALUEFUNC(SecurityType_EUROSOVEREIGNS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TIME_DEPOSIT", VALUEFUNC(SecurityType_TIME_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORPORATEBOND", VALUEFUNC(SecurityType_CORPORATEBOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FX_FORWARD", VALUEFUNC(SecurityType_FX_FORWARD_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_CORPORATE_FLOATING_RATE_NOTES", VALUEFUNC(SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_NOTE_TNOTE", VALUEFUNC(SecurityType_US_TREASURY_NOTE_TNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MORTGAGEBACKEDSECURITIES", VALUEFUNC(SecurityType_MORTGAGEBACKEDSECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_DEPOSIT_NOTES", VALUEFUNC(SecurityType_DEPOSIT_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORPORATEPRIVATEPLACEMENT", VALUEFUNC(SecurityType_CORPORATEPRIVATEPLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_HOUSING_AUTHORITY", VALUEFUNC(SecurityType_FEDERAL_HOUSING_AUTHORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MATURED", VALUEFUNC(SecurityType_MATURED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SWINGLINEFACILITY", VALUEFUNC(SecurityType_SWINGLINEFACILITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MULTI_LEG_INSTRUMENT", VALUEFUNC(SecurityType_MULTI_LEG_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_PROVINCIAL_BONDS", VALUEFUNC(SecurityType_CANADIAN_PROVINCIAL_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MEDIUM_TERM_NOTES", VALUEFUNC(SecurityType_MEDIUM_TERM_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_RETIRED", VALUEFUNC(SecurityType_RETIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MUTUAL_FUND", VALUEFUNC(SecurityType_MUTUAL_FUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURITIESPLEDGE", VALUEFUNC(SecurityType_SECURITIESPLEDGE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COMMERCIALPAPER", VALUEFUNC(SecurityType_COMMERCIALPAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REPURCHASE_AGREEMENT", VALUEFUNC(SecurityType_REPURCHASE_AGREEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BILL_OF_EXCHANGES", VALUEFUNC(SecurityType_BILL_OF_EXCHANGES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MUTUALFUND", VALUEFUNC(SecurityType_MUTUALFUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION", VALUEFUNC(SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EXTENDEDCOMMNOTE", VALUEFUNC(SecurityType_EXTENDEDCOMMNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_HOME_LOAN", VALUEFUNC(SecurityType_FEDERAL_HOME_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVOLVERLOAN", VALUEFUNC(SecurityType_REVOLVERLOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE", VALUEFUNC(SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_STRUCTURED_NOTES", VALUEFUNC(SecurityType_STRUCTURED_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INTERESTSTRIPFROMANYBONDORNOTE", VALUEFUNC(SecurityType_INTERESTSTRIPFROMANYBONDORNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CANADIAN_MORTGAGE_BONDS", VALUEFUNC(SecurityType_CANADIAN_MORTGAGE_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REPURCHASE", VALUEFUNC(SecurityType_REPURCHASE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_AGENCY_POOLS", VALUEFUNC(SecurityType_AGENCY_POOLS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_CORPORATE_BOND", VALUEFUNC(SecurityType_EURO_CORPORATE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SWING_LINE_FACILITY", VALUEFUNC(SecurityType_SWING_LINE_FACILITY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USDSUPRANATIONALCOUPONS", VALUEFUNC(SecurityType_USDSUPRANATIONALCOUPONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVOLVERTERMLOAN", VALUEFUNC(SecurityType_REVOLVERTERMLOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_LIQUIDITY_NOTE", VALUEFUNC(SecurityType_LIQUIDITY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MISCELLANEOUSPASSTHROUGH", VALUEFUNC(SecurityType_MISCELLANEOUSPASSTHROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CONVERTIBLE_BOND", VALUEFUNC(SecurityType_CONVERTIBLE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_ASSET_BACKED_SECURITIES", VALUEFUNC(SecurityType_ASSET_BACKED_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WILDCARDENTRY", VALUEFUNC(SecurityType_WILDCARDENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_YANKEECORPORATEBOND", VALUEFUNC(SecurityType_YANKEECORPORATEBOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TAXREVENUEANTICIPATIONNOTE", VALUEFUNC(SecurityType_TAXREVENUEANTICIPATIONNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION", VALUEFUNC(SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BRADYBOND", VALUEFUNC(SecurityType_BRADYBOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_USTREASURYBILL", VALUEFUNC(SecurityType_USTREASURYBILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION", VALUEFUNC(SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EUROCORPORATEBOND", VALUEFUNC(SecurityType_EUROCORPORATEBOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FUTURE", VALUEFUNC(SecurityType_FUTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BILL_TBILL", VALUEFUNC(SecurityType_US_TREASURY_BILL_TBILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE", VALUEFUNC(SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_CERTIFICATE_OF_DEPOSIT", VALUEFUNC(SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANKERS_ACCEPTANCE", VALUEFUNC(SecurityType_BANKERS_ACCEPTANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_AMENDEDRESTATED", VALUEFUNC(SecurityType_AMENDEDRESTATED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TERM_LOAN", VALUEFUNC(SecurityType_TERM_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANKNOTES", VALUEFUNC(SecurityType_BANKNOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SHORT_TERM_LOAN_NOTE", VALUEFUNC(SecurityType_SHORT_TERM_LOAN_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_AMENDED_RESTATED", VALUEFUNC(SecurityType_AMENDED_RESTATED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INTEREST_RATE_SWAP", VALUEFUNC(SecurityType_INTEREST_RATE_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EUROCOMMERCIALPAPER", VALUEFUNC(SecurityType_EUROCOMMERCIALPAPER_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_NOTE_UST", VALUEFUNC(SecurityType_US_TREASURY_NOTE_UST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BILL_USTB", VALUEFUNC(SecurityType_US_TREASURY_BILL_USTB_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION", VALUEFUNC(SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WITHDRAWN", VALUEFUNC(SecurityType_WITHDRAWN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORPORATE_PRIVATE_PLACEMENT", VALUEFUNC(SecurityType_CORPORATE_PRIVATE_PLACEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATE_OF_OBLIGATION", VALUEFUNC(SecurityType_CERTIFICATE_OF_OBLIGATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE", VALUEFUNC(SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_STRUCTUREDNOTES", VALUEFUNC(SecurityType_STRUCTUREDNOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANKERSACCEPTANCE", VALUEFUNC(SecurityType_BANKERSACCEPTANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_NO_ISITC_SECURITY_TYPE", VALUEFUNC(SecurityType_NO_ISITC_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CALLLOANS", VALUEFUNC(SecurityType_CALLLOANS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MISCELLANEOUS_PASS_THROUGH", VALUEFUNC(SecurityType_MISCELLANEOUS_PASS_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERAL_AGENCY_COUPON", VALUEFUNC(SecurityType_FEDERAL_AGENCY_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORPORATE_BOND", VALUEFUNC(SecurityType_CORPORATE_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST", VALUEFUNC(SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CORPMORTGAGEBACKEDSECURITIES", VALUEFUNC(SecurityType_CORPMORTGAGEBACKEDSECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_EURO_SUPRANATIONAL_COUPONS", VALUEFUNC(SecurityType_EURO_SUPRANATIONAL_COUPONS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CALL_LOANS", VALUEFUNC(SecurityType_CALL_LOANS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_CERTIFICATEOFDEPOSIT", VALUEFUNC(SecurityType_CERTIFICATEOFDEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURED_LIQUIDITY_NOTE", VALUEFUNC(SecurityType_SECURED_LIQUIDITY_NOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_TIMEDEPOSIT", VALUEFUNC(SecurityType_TIMEDEPOSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BANK_NOTES", VALUEFUNC(SecurityType_BANK_NOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_US_TREASURY_BILL", VALUEFUNC(SecurityType_US_TREASURY_BILL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_GENERALOBLIGATIONBONDS", VALUEFUNC(SecurityType_GENERALOBLIGATIONBONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COMMONSTOCK", VALUEFUNC(SecurityType_COMMONSTOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PLAZOSFIJOS", VALUEFUNC(SecurityType_PLAZOSFIJOS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURITIES_LOAN", VALUEFUNC(SecurityType_SECURITIES_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SECURITIESLOAN", VALUEFUNC(SecurityType_SECURITIESLOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_MUNICIPAL_BOND", VALUEFUNC(SecurityType_MUNICIPAL_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_REVENUE_BONDS", VALUEFUNC(SecurityType_REVENUE_BONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_SPECIALTAX", VALUEFUNC(SecurityType_SPECIALTAX_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE", VALUEFUNC(SecurityType_PRINCIPALSTRIPFROMANONCALLABLEBONDORNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_BRIDGE_LOAN", VALUEFUNC(SecurityType_BRIDGE_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_IOETTEMORTGAGE", VALUEFUNC(SecurityType_IOETTEMORTGAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERALAGENCYCOUPON", VALUEFUNC(SecurityType_FEDERALAGENCYCOUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_COMMON_STOCK", VALUEFUNC(SecurityType_COMMON_STOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityType_FEDERALAGENCYDISCOUNTNOTE", VALUEFUNC(SecurityType_FEDERALAGENCYDISCOUNTNOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUNDUP", VALUEFUNC(RoundingDirection_ROUNDUP_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUND_DOWN", VALUEFUNC(RoundingDirection_ROUND_DOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUND_TO_NEAREST", VALUEFUNC(RoundingDirection_ROUND_TO_NEAREST_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUND_UP", VALUEFUNC(RoundingDirection_ROUND_UP_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUNDDOWN", VALUEFUNC(RoundingDirection_ROUNDDOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "RoundingDirection_ROUNDNEAREST", VALUEFUNC(RoundingDirection_ROUNDNEAREST_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_MINUTE", VALUEFUNC(TimeUnit_MINUTE_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_WEEK", VALUEFUNC(TimeUnit_WEEK_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_SECOND", VALUEFUNC(TimeUnit_SECOND_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_MONTH", VALUEFUNC(TimeUnit_MONTH_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_HOUR", VALUEFUNC(TimeUnit_HOUR_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_DAY", VALUEFUNC(TimeUnit_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TimeUnit_YEAR", VALUEFUNC(TimeUnit_YEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_MODIFIED_DURATION", VALUEFUNC(LegSwapType_MODIFIED_DURATION_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_PARFORPAR", VALUEFUNC(LegSwapType_PARFORPAR_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_RISK", VALUEFUNC(LegSwapType_RISK_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_PAR_FOR_PAR", VALUEFUNC(LegSwapType_PAR_FOR_PAR_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_MODIFIEDDURATION", VALUEFUNC(LegSwapType_MODIFIEDDURATION_get), 0);
  rb_define_singleton_method(mQuickfix, "LegSwapType_PROCEEDS", VALUEFUNC(LegSwapType_PROCEEDS_get), 0);
  rb_define_singleton_method(mQuickfix, "IOITransType_REPLACE", VALUEFUNC(IOITransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "IOITransType_NEW", VALUEFUNC(IOITransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "IOITransType_CANCEL", VALUEFUNC(IOITransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED", VALUEFUNC(PosReqResult_REQUESTFORPOSITIONNOTSUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_VALID_REQUEST", VALUEFUNC(PosReqResult_VALID_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA", VALUEFUNC(PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS", VALUEFUNC(PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST", VALUEFUNC(PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS", VALUEFUNC(PosReqResult_NOTAUTHORIZEDTOREQUESTPOSITIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_OTHER", VALUEFUNC(PosReqResult_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA", VALUEFUNC(PosReqResult_NOPOSITIONSFOUNDTHATMATCHCRITERIA_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED", VALUEFUNC(PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_INVALIDORUNSUPPORTEDREQUEST", VALUEFUNC(PosReqResult_INVALIDORUNSUPPORTEDREQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqResult_VALIDREQUEST", VALUEFUNC(PosReqResult_VALIDREQUEST_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_ACCOUNTOVERRIDING", VALUEFUNC(SettlInstMode_ACCOUNTOVERRIDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_REJECT", VALUEFUNC(SettlInstMode_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_DEFAULT", VALUEFUNC(SettlInstMode_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_REQUEST_REJECT", VALUEFUNC(SettlInstMode_REQUEST_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING", VALUEFUNC(SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_SIPROVIDED", VALUEFUNC(SettlInstMode_SIPROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_ACCOUNTSTANDING", VALUEFUNC(SettlInstMode_ACCOUNTSTANDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_CIVORDERSINGLEACCT", VALUEFUNC(SettlInstMode_CIVORDERSINGLEACCT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING", VALUEFUNC(SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT", VALUEFUNC(SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED", VALUEFUNC(SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "PreviouslyReported_NO", VALUEFUNC(PreviouslyReported_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PreviouslyReported_YES", VALUEFUNC(PreviouslyReported_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_PEGGED", VALUEFUNC(CustOrderHandlingInst_PEGGED_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_ON_OPEN", VALUEFUNC(CustOrderHandlingInst_MARKET_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_SCALE", VALUEFUNC(CustOrderHandlingInst_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_FILL_OR_KILL", VALUEFUNC(CustOrderHandlingInst_FILL_OR_KILL_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_ALL_OR_NONE", VALUEFUNC(CustOrderHandlingInst_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_NOT_HELD", VALUEFUNC(CustOrderHandlingInst_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_DIRECTED_ORDER", VALUEFUNC(CustOrderHandlingInst_DIRECTED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_STOP_STOCK_TRANSACTION", VALUEFUNC(CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_OVER_THE_DAY", VALUEFUNC(CustOrderHandlingInst_OVER_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_ADD_ON_ORDER", VALUEFUNC(CustOrderHandlingInst_ADD_ON_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_AT_CLOSE", VALUEFUNC(CustOrderHandlingInst_MARKET_AT_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_LIMIT_ON_OPEN", VALUEFUNC(CustOrderHandlingInst_LIMIT_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_CASH_NOT_HELD", VALUEFUNC(CustOrderHandlingInst_CASH_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_ON_CLOSE", VALUEFUNC(CustOrderHandlingInst_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_TIME_ORDER", VALUEFUNC(CustOrderHandlingInst_TIME_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_LIMIT_ON_CLOSE", VALUEFUNC(CustOrderHandlingInst_LIMIT_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_IMMEDIATE_OR_CANCEL", VALUEFUNC(CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_TRAILING_STOP", VALUEFUNC(CustOrderHandlingInst_TRAILING_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_WORK", VALUEFUNC(CustOrderHandlingInst_WORK_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_RESERVE_SIZE_ORDER", VALUEFUNC(CustOrderHandlingInst_RESERVE_SIZE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MINIMUM_QUANTITY", VALUEFUNC(CustOrderHandlingInst_MINIMUM_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_MARKET_AT_OPEN", VALUEFUNC(CustOrderHandlingInst_MARKET_AT_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_IMBALANCE_ONLY", VALUEFUNC(CustOrderHandlingInst_IMBALANCE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION", VALUEFUNC(CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityStatus_INACTIVE", VALUEFUNC(SecurityStatus_INACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityStatus_ACTIVE", VALUEFUNC(SecurityStatus_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_SOFT_DOLLAR", VALUEFUNC(ProcessCode_SOFT_DOLLAR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEPOUTSOFT", VALUEFUNC(ProcessCode_STEPOUTSOFT_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEPOUT", VALUEFUNC(ProcessCode_STEPOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_PLAN_SPONSOR", VALUEFUNC(ProcessCode_PLAN_SPONSOR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEP_IN", VALUEFUNC(ProcessCode_STEP_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEPIN", VALUEFUNC(ProcessCode_STEPIN_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_REGULAR", VALUEFUNC(ProcessCode_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_SOFTDOLLAR", VALUEFUNC(ProcessCode_SOFTDOLLAR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_PLANSPONSOR", VALUEFUNC(ProcessCode_PLANSPONSOR_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEPINSOFT", VALUEFUNC(ProcessCode_STEPINSOFT_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_SOFT_DOLLAR_STEP_OUT", VALUEFUNC(ProcessCode_SOFT_DOLLAR_STEP_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_STEP_OUT", VALUEFUNC(ProcessCode_STEP_OUT_get), 0);
  rb_define_singleton_method(mQuickfix, "ProcessCode_SOFT_DOLLAR_STEP_IN", VALUEFUNC(ProcessCode_SOFT_DOLLAR_STEP_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRY_TO_STOP", VALUEFUNC(ExecInst_TRY_TO_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PEG_TO_LIMIT_PRICE", VALUEFUNC(ExecInst_PEG_TO_LIMIT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXECUTE_AS_DURATION_NEUTRAL", VALUEFUNC(ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PARTICIPANT_DONT_INITIATE", VALUEFUNC(ExecInst_PARTICIPANT_DONT_INITIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_TRADING_HALT", VALUEFUNC(ExecInst_REINSTATE_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NO_CROSS", VALUEFUNC(ExecInst_NO_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PEGVWAP", VALUEFUNC(ExecInst_PEGVWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STRICT_SCALE", VALUEFUNC(ExecInst_STRICT_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_AON", VALUEFUNC(ExecInst_AON_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRAILING_STOP_PEG", VALUEFUNC(ExecInst_TRAILING_STOP_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRAILSTOPPEG", VALUEFUNC(ExecInst_TRAILSTOPPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MARKPEG", VALUEFUNC(ExecInst_MARKPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MIDPRCPEG", VALUEFUNC(ExecInst_MIDPRCPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OKCROSS", VALUEFUNC(ExecInst_OKCROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXECUTE_AS_FX_NEUTRAL", VALUEFUNC(ExecInst_EXECUTE_AS_FX_NEUTRAL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CUSTDISPINST", VALUEFUNC(ExecInst_CUSTDISPINST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_IGNOREPRICECHK", VALUEFUNC(ExecInst_IGNOREPRICECHK_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STRICTLIMIT", VALUEFUNC(ExecInst_STRICTLIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_WORKTOSTRATEGY", VALUEFUNC(ExecInst_WORKTOSTRATEGY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OK_TO_CROSS", VALUEFUNC(ExecInst_OK_TO_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND_ON_SYSTEM_FAILURE", VALUEFUNC(ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_SYSTEM_FAILURE", VALUEFUNC(ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_GO_ALONG", VALUEFUNC(ExecInst_GO_ALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_INSTITONLY", VALUEFUNC(ExecInst_INSTITONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DO_NOT_INCREASE", VALUEFUNC(ExecInst_DO_NOT_INCREASE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND", VALUEFUNC(ExecInst_SUSPEND_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRYTOSTOP", VALUEFUNC(ExecInst_TRYTOSTOP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER", VALUEFUNC(ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND_ON_TRADING_HALT", VALUEFUNC(ExecInst_SUSPEND_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_INTERMARKET_SWEEP", VALUEFUNC(ExecInst_INTERMARKET_SWEEP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_IGNORE_PRICE_VALIDITY_CHECKS", VALUEFUNC(ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PARTICIPATE_DONT_INITIATE", VALUEFUNC(ExecInst_PARTICIPATE_DONT_INITIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_LASTPEG", VALUEFUNC(ExecInst_LASTPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PEG_TO_VWAP", VALUEFUNC(ExecInst_PEG_TO_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PRIMARY_PEG", VALUEFUNC(ExecInst_PRIMARY_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NONNEGO", VALUEFUNC(ExecInst_NONNEGO_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_BEST_EXECUTION", VALUEFUNC(ExecInst_BEST_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_BID_SIDE", VALUEFUNC(ExecInst_STAY_ON_BID_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NOTHELD", VALUEFUNC(ExecInst_NOTHELD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STRICTSCALE", VALUEFUNC(ExecInst_STRICTSCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_CONNECTION_LOSS", VALUEFUNC(ExecInst_REINSTATE_ON_CONNECTION_LOSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DNI", VALUEFUNC(ExecInst_DNI_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRYTOSCALE", VALUEFUNC(ExecInst_TRYTOSCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PERCENT_OF_VOLUME", VALUEFUNC(ExecInst_PERCENT_OF_VOLUME_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_GOALONG", VALUEFUNC(ExecInst_GOALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_WORK", VALUEFUNC(ExecInst_WORK_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_HELD", VALUEFUNC(ExecInst_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NOCROSS", VALUEFUNC(ExecInst_NOCROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_RELEASE_FROM_SUSPENSION", VALUEFUNC(ExecInst_RELEASE_FROM_SUSPENSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STRICT_LIMIT", VALUEFUNC(ExecInst_STRICT_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OPENPEG", VALUEFUNC(ExecInst_OPENPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_BIDSIDE", VALUEFUNC(ExecInst_STAY_ON_BIDSIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_OFFERSIDE", VALUEFUNC(ExecInst_STAY_ON_OFFERSIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OVER_THE_DAY", VALUEFUNC(ExecInst_OVER_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_RESTATEONTRADINGHALT", VALUEFUNC(ExecInst_RESTATEONTRADINGHALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_INSTITUTIONS_ONLY", VALUEFUNC(ExecInst_INSTITUTIONS_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NOT_HELD", VALUEFUNC(ExecInst_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCELONTRADINGHALT", VALUEFUNC(ExecInst_CANCELONTRADINGHALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCELONSYSFAIL", VALUEFUNC(ExecInst_CANCELONSYSFAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_ON_SYSTEM_FAILURE", VALUEFUNC(ExecInst_CANCEL_ON_SYSTEM_FAILURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MARKET_PEG", VALUEFUNC(ExecInst_MARKET_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRADEALONG", VALUEFUNC(ExecInst_TRADEALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CALL_FIRST", VALUEFUNC(ExecInst_CALL_FIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PEGTOLIMIT", VALUEFUNC(ExecInst_PEGTOLIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED", VALUEFUNC(ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE", VALUEFUNC(ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NON_NEGOTIABLE", VALUEFUNC(ExecInst_NON_NEGOTIABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRY_TO_SCALE", VALUEFUNC(ExecInst_TRY_TO_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXTERNAL_ROUTING_ALLOWED", VALUEFUNC(ExecInst_EXTERNAL_ROUTING_ALLOWED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_WORK_TO_TARGET_STRATEGY", VALUEFUNC(ExecInst_WORK_TO_TARGET_STRATEGY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAY_ON_OFFER_SIDE", VALUEFUNC(ExecInst_STAY_ON_OFFER_SIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CUSTOMER_DISPLAY_INSTRUCTION", VALUEFUNC(ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OVERDAY", VALUEFUNC(ExecInst_OVERDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_LAST_PEG", VALUEFUNC(ExecInst_LAST_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CALLFIRST", VALUEFUNC(ExecInst_CALLFIRST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_REINSTATE_ON_SYSTEM_FAILUE", VALUEFUNC(ExecInst_REINSTATE_ON_SYSTEM_FAILUE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DO_NOT_REDUCE", VALUEFUNC(ExecInst_DO_NOT_REDUCE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_MID_PRICE_PEG", VALUEFUNC(ExecInst_MID_PRICE_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_ALL_OR_NONE", VALUEFUNC(ExecInst_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_OPENING_PEG", VALUEFUNC(ExecInst_OPENING_PEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PERCVOL", VALUEFUNC(ExecInst_PERCVOL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_SUSPEND_ON_CONNECTION_LOSS", VALUEFUNC(ExecInst_SUSPEND_ON_CONNECTION_LOSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_ON_CONNECTION_LOSS", VALUEFUNC(ExecInst_CANCEL_ON_CONNECTION_LOSS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED", VALUEFUNC(ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_IF_NOT_BEST", VALUEFUNC(ExecInst_CANCEL_IF_NOT_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PARTNOTINIT", VALUEFUNC(ExecInst_PARTNOTINIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CXLIFNOTBEST", VALUEFUNC(ExecInst_CXLIFNOTBEST_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_NETTING", VALUEFUNC(ExecInst_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_IMBALANCE_ONLY", VALUEFUNC(ExecInst_IMBALANCE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_CANCEL_ON_TRADING_HALT", VALUEFUNC(ExecInst_CANCEL_ON_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_TRADE_ALONG", VALUEFUNC(ExecInst_TRADE_ALONG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_DNR", VALUEFUNC(ExecInst_DNR_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAYOFFER", VALUEFUNC(ExecInst_STAYOFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_STAYBID", VALUEFUNC(ExecInst_STAYBID_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_RESTATEONSYSFAIL", VALUEFUNC(ExecInst_RESTATEONSYSFAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecInst_PRIMPEG", VALUEFUNC(ExecInst_PRIMPEG_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_REPLACE", VALUEFUNC(ExecType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_NEW", VALUEFUNC(ExecType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_CALCULATED", VALUEFUNC(ExecType_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDINGNEW", VALUEFUNC(ExecType_PENDINGNEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_ORDERSTATUS", VALUEFUNC(ExecType_ORDERSTATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_CANCEL", VALUEFUNC(ExecType_PENDING_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_IN_A_CLEARING_HOLD", VALUEFUNC(ExecType_TRADE_IN_A_CLEARING_HOLD_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING", VALUEFUNC(ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_ORDER_STATUS", VALUEFUNC(ExecType_ORDER_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_CANCEL_REPLACE", VALUEFUNC(ExecType_PENDING_CANCEL_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PARTIAL_FILL", VALUEFUNC(ExecType_PARTIAL_FILL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDINGCXL", VALUEFUNC(ExecType_PENDINGCXL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_NEW", VALUEFUNC(ExecType_PENDING_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_STOPPED", VALUEFUNC(ExecType_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_CANCELED", VALUEFUNC(ExecType_CANCELED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDING_REPLACE", VALUEFUNC(ExecType_PENDING_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE", VALUEFUNC(ExecType_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_CORRECT", VALUEFUNC(ExecType_TRADE_CORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_PENDINGREPLACE", VALUEFUNC(ExecType_PENDINGREPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_SUSPENDED", VALUEFUNC(ExecType_SUSPENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_FILL", VALUEFUNC(ExecType_FILL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_DONE", VALUEFUNC(ExecType_DONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_RESTATED", VALUEFUNC(ExecType_RESTATED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_REJECTED", VALUEFUNC(ExecType_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_REPLACED", VALUEFUNC(ExecType_REPLACED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_EXPIRED", VALUEFUNC(ExecType_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_DONE_FOR_DAY", VALUEFUNC(ExecType_DONE_FOR_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM", VALUEFUNC(ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADECORRECT", VALUEFUNC(ExecType_TRADECORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADECANCEL", VALUEFUNC(ExecType_TRADECANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_TRADE_CANCEL", VALUEFUNC(ExecType_TRADE_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecType_CANCELLED", VALUEFUNC(ExecType_CANCELLED_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegModel_USER_DEFINED_MULTLEG_SECURITY", VALUEFUNC(MultilegModel_USER_DEFINED_MULTLEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegModel_PREDEFINED_MULTILEG_SECURITY", VALUEFUNC(MultilegModel_PREDEFINED_MULTILEG_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG", VALUEFUNC(MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_NEXT_START_DATE", VALUEFUNC(EventType_SWAP_NEXT_START_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_LAST_ELIGIBLE_TRADE_DATE", VALUEFUNC(EventType_LAST_ELIGIBLE_TRADE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_FIRST_DELIVERY_DATE", VALUEFUNC(EventType_FIRST_DELIVERY_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_TENDER", VALUEFUNC(EventType_TENDER_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_INITIAL_INVENTORY_DUE_DATE", VALUEFUNC(EventType_INITIAL_INVENTORY_DUE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_FIRST_INTENT_DATE", VALUEFUNC(EventType_FIRST_INTENT_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_ACTIVATION", VALUEFUNC(EventType_ACTIVATION_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_PUT", VALUEFUNC(EventType_PUT_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_START_DATE", VALUEFUNC(EventType_SWAP_START_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_NEXT_ROLL_DATE", VALUEFUNC(EventType_SWAP_NEXT_ROLL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_LAST_DELIVERY_DATE", VALUEFUNC(EventType_LAST_DELIVERY_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_POSITION_REMOVAL_DATE", VALUEFUNC(EventType_POSITION_REMOVAL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_ROLL_DATE", VALUEFUNC(EventType_SWAP_ROLL_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_FINAL_INVENTORY_DUE_DATE", VALUEFUNC(EventType_FINAL_INVENTORY_DUE_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_OTHER", VALUEFUNC(EventType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_INACTIVIATION", VALUEFUNC(EventType_INACTIVIATION_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SINKINGFUNDCALL", VALUEFUNC(EventType_SINKINGFUNDCALL_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SWAP_END_DATE", VALUEFUNC(EventType_SWAP_END_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_LAST_INTENT_DATE", VALUEFUNC(EventType_LAST_INTENT_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_SINKING_FUND_CALL", VALUEFUNC(EventType_SINKING_FUND_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "EventType_CALL", VALUEFUNC(EventType_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED", VALUEFUNC(TradeAllocIndicator_ALLOCATIONREQUIREDALLOCATIONINFORMATIONNOTPROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_REQUIRED", VALUEFUNC(TradeAllocIndicator_ALLOCATION_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT", VALUEFUNC(TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE", VALUEFUNC(TradeAllocIndicator_USEALLOCATIONPROVIDEDWITHTHETRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR", VALUEFUNC(TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE", VALUEFUNC(TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATIONNOTREQUIRED", VALUEFUNC(TradeAllocIndicator_ALLOCATIONNOTREQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_NOT_REQUIRED", VALUEFUNC(TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR", VALUEFUNC(TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_NOT_LOGGED_IN", VALUEFUNC(UserStatus_NOT_LOGGED_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_PASSWORD_INCORRECT", VALUEFUNC(UserStatus_PASSWORD_INCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_USERNOTRECOGNISED", VALUEFUNC(UserStatus_USERNOTRECOGNISED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_LOGGED_IN", VALUEFUNC(UserStatus_LOGGED_IN_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_PASSWORDCHANGED", VALUEFUNC(UserStatus_PASSWORDCHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE", VALUEFUNC(UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_USER_NOT_RECOGNISED", VALUEFUNC(UserStatus_USER_NOT_RECOGNISED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_NOTLOGGEDIN", VALUEFUNC(UserStatus_NOTLOGGEDIN_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_PASSWORD_CHANGED", VALUEFUNC(UserStatus_PASSWORD_CHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_OTHER", VALUEFUNC(UserStatus_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_LOGGEDIN", VALUEFUNC(UserStatus_LOGGEDIN_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_SESSION_SHUTDOWN_WARNING", VALUEFUNC(UserStatus_SESSION_SHUTDOWN_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "UserStatus_PASSWORDINCORRECT", VALUEFUNC(UserStatus_PASSWORDINCORRECT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrRegistry_PHYSICAL", VALUEFUNC(InstrRegistry_PHYSICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrRegistry_COUNTRY", VALUEFUNC(InstrRegistry_COUNTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrRegistry_CUSTODIAN", VALUEFUNC(InstrRegistry_CUSTODIAN_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_WEEKS", VALUEFUNC(OrderDelayUnit_WEEKS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_TENTHS_OF_A_SECOND", VALUEFUNC(OrderDelayUnit_TENTHS_OF_A_SECOND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_SECONDS", VALUEFUNC(OrderDelayUnit_SECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MONTHS", VALUEFUNC(OrderDelayUnit_MONTHS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_YEARS", VALUEFUNC(OrderDelayUnit_YEARS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_NANOSECONDS", VALUEFUNC(OrderDelayUnit_NANOSECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_HUNDREDTHS_OF_A_SECOND", VALUEFUNC(OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_HOURS", VALUEFUNC(OrderDelayUnit_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MICROSECONDS", VALUEFUNC(OrderDelayUnit_MICROSECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MINUTES", VALUEFUNC(OrderDelayUnit_MINUTES_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_MILLISECONDS", VALUEFUNC(OrderDelayUnit_MILLISECONDS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrderDelayUnit_DAYS", VALUEFUNC(OrderDelayUnit_DAYS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradedFlatSwitch_NO", VALUEFUNC(TradedFlatSwitch_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "TradedFlatSwitch_YES", VALUEFUNC(TradedFlatSwitch_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRptStatus_ACCEPTED_WITH_ERRORS", VALUEFUNC(TrdRptStatus_ACCEPTED_WITH_ERRORS_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRptStatus_REJECTED", VALUEFUNC(TrdRptStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TrdRptStatus_ACCEPTED", VALUEFUNC(TrdRptStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELEDDUETOLOCKMARKET", VALUEFUNC(QuoteStatus_CANCELEDDUETOLOCKMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_REJ", VALUEFUNC(QuoteStatus_REJ_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_PENDING", VALUEFUNC(QuoteStatus_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_LOCKEDMARKETWARNING", VALUEFUNC(QuoteStatus_LOCKEDMARKETWARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CROSSMARKETWARNING", VALUEFUNC(QuoteStatus_CROSSMARKETWARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_REMOVED", VALUEFUNC(QuoteStatus_REMOVED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CXLUNDER", VALUEFUNC(QuoteStatus_CXLUNDER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_PENDING_END_TRADE", VALUEFUNC(QuoteStatus_PENDING_END_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CROSS_MARKET_WARNING", VALUEFUNC(QuoteStatus_CROSS_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_QUOTENOTFOUND", VALUEFUNC(QuoteStatus_QUOTENOTFOUND_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED", VALUEFUNC(QuoteStatus_CANCELED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_LOCKED_MARKET_WARNING", VALUEFUNC(QuoteStatus_LOCKED_MARKET_WARNING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CXLSYM", VALUEFUNC(QuoteStatus_CXLSYM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_FOR_UNDERLYING", VALUEFUNC(QuoteStatus_CANCELED_FOR_UNDERLYING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT", VALUEFUNC(QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_TOO_LATE_TO_END", VALUEFUNC(QuoteStatus_TOO_LATE_TO_END_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET", VALUEFUNC(QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET", VALUEFUNC(QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_ACCPT", VALUEFUNC(QuoteStatus_ACCPT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_FOR_SECURITY_TYPE", VALUEFUNC(QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_ALL", VALUEFUNC(QuoteStatus_CANCELED_ALL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_PASS", VALUEFUNC(QuoteStatus_PASS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELEDDUETOCROSSMARKET", VALUEFUNC(QuoteStatus_CANCELEDDUETOCROSSMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_REJECTED", VALUEFUNC(QuoteStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_QUERY", VALUEFUNC(QuoteStatus_QUERY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CXLSECTYPE", VALUEFUNC(QuoteStatus_CXLSECTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_ACCEPTED", VALUEFUNC(QuoteStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_EXPIRED", VALUEFUNC(QuoteStatus_EXPIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCELED_FOR_SYMBOL", VALUEFUNC(QuoteStatus_CANCELED_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_REMOVED_FROM_MARKET", VALUEFUNC(QuoteStatus_REMOVED_FROM_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_ACTIVE", VALUEFUNC(QuoteStatus_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CANCEL_FOR_SYMBOL", VALUEFUNC(QuoteStatus_CANCEL_FOR_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_CXLALL", VALUEFUNC(QuoteStatus_CXLALL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteStatus_QUOTE_NOT_FOUND", VALUEFUNC(QuoteStatus_QUOTE_NOT_FOUND_get), 0);
  rb_define_singleton_method(mQuickfix, "SolicitedFlag_NO", VALUEFUNC(SolicitedFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "SolicitedFlag_YES", VALUEFUNC(SolicitedFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "RiskLimitType_GROSS_LIMIT", VALUEFUNC(RiskLimitType_GROSS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "RiskLimitType_SHORT_LIMIT", VALUEFUNC(RiskLimitType_SHORT_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "RiskLimitType_LONG_LIMIT", VALUEFUNC(RiskLimitType_LONG_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "RiskLimitType_NET_LIMIT", VALUEFUNC(RiskLimitType_NET_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "RiskLimitType_EXPOSURE", VALUEFUNC(RiskLimitType_EXPOSURE_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_DEALER_SOLD_SHORT", VALUEFUNC(ShortSaleReason_DEALER_SOLD_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_DEALERSOLDSHORTEXEMPT", VALUEFUNC(ShortSaleReason_DEALERSOLDSHORTEXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT", VALUEFUNC(ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_DEALERSOLDSHORT", VALUEFUNC(ShortSaleReason_DEALERSOLDSHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT", VALUEFUNC(ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT", VALUEFUNC(ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_SELLINGCUSTOMERSOLDSHORT", VALUEFUNC(ShortSaleReason_SELLINGCUSTOMERSOLDSHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT", VALUEFUNC(ShortSaleReason_SELLINGCUSTOMERSOLDSHORTEXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT", VALUEFUNC(ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT", VALUEFUNC(ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE", VALUEFUNC(ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT", VALUEFUNC(ShortSaleReason_QSRORAGUCONTRASIDESOLDSHORTEXEMPT_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MOREPASSIVE", VALUEFUNC(PegRoundDirection_MOREPASSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MOREAGGRESSIVE", VALUEFUNC(PegRoundDirection_MOREAGGRESSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MORE_AGGRESSIVE", VALUEFUNC(PegRoundDirection_MORE_AGGRESSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "PegRoundDirection_MORE_PASSIVE", VALUEFUNC(PegRoundDirection_MORE_PASSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "ModelType_PROPRIETARY", VALUEFUNC(ModelType_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "ModelType_UTILITY_PROVIDED_STANDARD_MODEL", VALUEFUNC(ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get), 0);
  rb_define_singleton_method(mQuickfix, "FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT", VALUEFUNC(FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "FuturesValuationMethod_PREMIUM_STYLE", VALUEFUNC(FuturesValuationMethod_PREMIUM_STYLE_get), 0);
  rb_define_singleton_method(mQuickfix, "FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET", VALUEFUNC(FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlMethod_CASH_SETTLEMENT_REQUIRED", VALUEFUNC(SettlMethod_CASH_SETTLEMENT_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED", VALUEFUNC(SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_CONFIRMED", VALUEFUNC(ConfirmStatus_CONFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_REQUESTREJECTED", VALUEFUNC(ConfirmStatus_REQUESTREJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS", VALUEFUNC(ConfirmStatus_MISSINGSETTLEMENTINSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS", VALUEFUNC(ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_REQUEST_REJECTED", VALUEFUNC(ConfirmStatus_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_MISMATCHEDACCOUNT", VALUEFUNC(ConfirmStatus_MISMATCHEDACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_MISMATCHED_ACCOUNT", VALUEFUNC(ConfirmStatus_MISMATCHED_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmStatus_RECEIVED", VALUEFUNC(ConfirmStatus_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "LocateReqd_NO", VALUEFUNC(LocateReqd_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LocateReqd_YES", VALUEFUNC(LocateReqd_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "Adjustment_CANCEL", VALUEFUNC(Adjustment_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "Adjustment_CORRECTION", VALUEFUNC(Adjustment_CORRECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "Adjustment_ERROR", VALUEFUNC(Adjustment_ERROR_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnType_ASSIGNMENT", VALUEFUNC(StreamAsgnType_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnType_TERMINATE_UNASSIGN", VALUEFUNC(StreamAsgnType_TERMINATE_UNASSIGN_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnType_REJECTED", VALUEFUNC(StreamAsgnType_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "LastRptRequested_NO", VALUEFUNC(LastRptRequested_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LastRptRequested_YES", VALUEFUNC(LastRptRequested_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_END_OF_DAY", VALUEFUNC(SettlSessID_END_OF_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_REGULAR_TRADING_HOURS", VALUEFUNC(SettlSessID_REGULAR_TRADING_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_ELECTRONIC_TRADING_HOURS", VALUEFUNC(SettlSessID_ELECTRONIC_TRADING_HOURS_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlSessID_INTRADAY", VALUEFUNC(SettlSessID_INTRADAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_NO_WAS", VALUEFUNC(TradeReportType_NO_WAS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ADDENDUM", VALUEFUNC(TradeReportType_ADDENDUM_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_7", VALUEFUNC(TradeReportType_7_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_PENDED", VALUEFUNC(TradeReportType_PENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_LOCKEDINTRADEBREAK", VALUEFUNC(TradeReportType_LOCKEDINTRADEBREAK_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_DEFAULTED", VALUEFUNC(TradeReportType_DEFAULTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_DECLINE", VALUEFUNC(TradeReportType_DECLINE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_NEW", VALUEFUNC(TradeReportType_ALLEGED_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_TRADE_REPORT_CANCEL", VALUEFUNC(TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_15", VALUEFUNC(TradeReportType_ALLEGED_15_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_ADDENDUM", VALUEFUNC(TradeReportType_ALLEGED_ADDENDUM_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED", VALUEFUNC(TradeReportType_ALLEGED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_SUBMIT", VALUEFUNC(TradeReportType_SUBMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_NOWAS", VALUEFUNC(TradeReportType_NOWAS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_1", VALUEFUNC(TradeReportType_ALLEGED_1_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_INVALID_CMTA", VALUEFUNC(TradeReportType_INVALID_CMTA_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_TRADEREPORTCANCEL", VALUEFUNC(TradeReportType_TRADEREPORTCANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_TRADE_REPORT_CANCEL", VALUEFUNC(TradeReportType_TRADE_REPORT_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ALLEGED_NO_WAS", VALUEFUNC(TradeReportType_ALLEGED_NO_WAS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeReportType_ACCEPT", VALUEFUNC(TradeReportType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseStyle_AMERICAN", VALUEFUNC(ExerciseStyle_AMERICAN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseStyle_EUROPEAN", VALUEFUNC(ExerciseStyle_EUROPEAN_get), 0);
  rb_define_singleton_method(mQuickfix, "ExerciseStyle_BERMUDA", VALUEFUNC(ExerciseStyle_BERMUDA_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_EQUIPCHANGE", VALUEFUNC(HaltReasonChar_EQUIPCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ADDITIONAL_INFORMATION", VALUEFUNC(HaltReasonChar_ADDITIONAL_INFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ORDINFL", VALUEFUNC(HaltReasonChar_ORDINFL_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEW_PENDING", VALUEFUNC(HaltReasonChar_NEW_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEWSDISS", VALUEFUNC(HaltReasonChar_NEWSDISS_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEWS_PENDING", VALUEFUNC(HaltReasonChar_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ORDER_INFLUX", VALUEFUNC(HaltReasonChar_ORDER_INFLUX_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEWS_DISSEMINATION", VALUEFUNC(HaltReasonChar_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ADDINFO", VALUEFUNC(HaltReasonChar_ADDINFO_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ORDIMB", VALUEFUNC(HaltReasonChar_ORDIMB_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_EQUIPMENT_CHANGEOVER", VALUEFUNC(HaltReasonChar_EQUIPMENT_CHANGEOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_ORDER_IMBALANCE", VALUEFUNC(HaltReasonChar_ORDER_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "HaltReasonChar_NEWSPEND", VALUEFUNC(HaltReasonChar_NEWSPEND_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestination_POSIT", VALUEFUNC(ExDestination_POSIT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExDestination_NONE", VALUEFUNC(ExDestination_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY", VALUEFUNC(AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_WAREHOUSE_RECAP", VALUEFUNC(AllocReportType_WAREHOUSE_RECAP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_REJECT", VALUEFUNC(AllocReportType_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_REQUESTTOINTERMEDIARY", VALUEFUNC(AllocReportType_REQUESTTOINTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_ACCEPT_PENDING", VALUEFUNC(AllocReportType_ACCEPT_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_REQUEST_TO_INTERMEDIARY", VALUEFUNC(AllocReportType_REQUEST_TO_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_COMPLETE", VALUEFUNC(AllocReportType_COMPLETE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY", VALUEFUNC(AllocReportType_SELLSIDECALCULATEDUSINGPRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY", VALUEFUNC(AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY", VALUEFUNC(AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_REVERSE_PENDING", VALUEFUNC(AllocReportType_REVERSE_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_WAREHOUSERECAP", VALUEFUNC(AllocReportType_WAREHOUSERECAP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_ACCEPT", VALUEFUNC(AllocReportType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY", VALUEFUNC(AllocReportType_SELLSIDECALCULATEDWITHOUTPRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDEREADYTOBOOKSINGLE", VALUEFUNC(AllocType_BUYSIDEREADYTOBOOKSINGLE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY", VALUEFUNC(AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_CALCULATED", VALUEFUNC(AllocType_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_INCOMPLETE_GROUP", VALUEFUNC(AllocType_INCOMPLETE_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_REVERSAL_PENDING", VALUEFUNC(AllocType_REVERSAL_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_PRELIMINARY", VALUEFUNC(AllocType_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_REJECT", VALUEFUNC(AllocType_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_WAREHOUSEINSTRUCTION", VALUEFUNC(AllocType_WAREHOUSEINSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDEPRELIM", VALUEFUNC(AllocType_BUYSIDEPRELIM_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_REQUESTTOINTERMEDIARY", VALUEFUNC(AllocType_REQUESTTOINTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_ACCEPT_PENDING", VALUEFUNC(AllocType_ACCEPT_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDEREADYTOBOOKCOMBINED", VALUEFUNC(AllocType_BUYSIDEREADYTOBOOKCOMBINED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_CALCULATED", VALUEFUNC(AllocType_BUYSIDE_CALCULATED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_REQUEST_TO_INTERMEDIARY", VALUEFUNC(AllocType_REQUEST_TO_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_SELLSIDECALCWITHOUTPRELIM", VALUEFUNC(AllocType_SELLSIDECALCWITHOUTPRELIM_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_READY_TO_BOOK_5", VALUEFUNC(AllocType_BUYSIDE_READY_TO_BOOK_5_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_READY_TO_BOOK_6", VALUEFUNC(AllocType_BUYSIDE_READY_TO_BOOK_6_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_COMPLETE_GROUP", VALUEFUNC(AllocType_COMPLETE_GROUP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDECALC", VALUEFUNC(AllocType_BUYSIDECALC_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY", VALUEFUNC(AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_READY_TO_BOOK", VALUEFUNC(AllocType_READY_TO_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_READY_TO_BOOK", VALUEFUNC(AllocType_BUYSIDE_READY_TO_BOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_WAREHOUSE_INSTRUCTION", VALUEFUNC(AllocType_WAREHOUSE_INSTRUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_BUYSIDE_PRELIMINARY", VALUEFUNC(AllocType_BUYSIDE_PRELIMINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_ACCEPT", VALUEFUNC(AllocType_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocType_SELLSIDECALC", VALUEFUNC(AllocType_SELLSIDECALC_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_INSUFFICIENT_CREDIT", VALUEFUNC(QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NOMARKETFORINSTRUMENT", VALUEFUNC(QuoteRequestRejectReason_NOMARKETFORINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NOTAUTHTOREQQUOTE", VALUEFUNC(QuoteRequestRejectReason_NOTAUTHTOREQQUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE", VALUEFUNC(QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT", VALUEFUNC(QuoteRequestRejectReason_QUOTEREQUESTEXLIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_INVALID_PRICE", VALUEFUNC(QuoteRequestRejectReason_INVALID_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_EXCHANGECLOSED", VALUEFUNC(QuoteRequestRejectReason_EXCHANGECLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_TOOLATE", VALUEFUNC(QuoteRequestRejectReason_TOOLATE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_INVPRICE", VALUEFUNC(QuoteRequestRejectReason_INVPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NOMATCHFORINQUIRY", VALUEFUNC(QuoteRequestRejectReason_NOMATCHFORINQUIRY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_TOO_LATE_TO_ENTER", VALUEFUNC(QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY", VALUEFUNC(QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_UNKNOWNSYM", VALUEFUNC(QuoteRequestRejectReason_UNKNOWNSYM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_EXCHANGE", VALUEFUNC(QuoteRequestRejectReason_EXCHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT", VALUEFUNC(QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_UNKNOWN_SYMBOL", VALUEFUNC(QuoteRequestRejectReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_OTHER", VALUEFUNC(QuoteRequestRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_PASS", VALUEFUNC(QuoteRequestRejectReason_PASS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NOINVENTORY", VALUEFUNC(QuoteRequestRejectReason_NOINVENTORY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_NO_INVENTORY", VALUEFUNC(QuoteRequestRejectReason_NO_INVENTORY_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT", VALUEFUNC(QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_5DAY", VALUEFUNC(LiquidityIndType_5DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_NORMAL", VALUEFUNC(LiquidityIndType_NORMAL_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_20_DAY_MOVING_AVERAGE", VALUEFUNC(LiquidityIndType_20_DAY_MOVING_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_5_DAY_MOVING_AVERAGE", VALUEFUNC(LiquidityIndType_5_DAY_MOVING_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_5DAY_MOVING_AVERAGE", VALUEFUNC(LiquidityIndType_5DAY_MOVING_AVERAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_NORMAL_MARKET_SIZE", VALUEFUNC(LiquidityIndType_NORMAL_MARKET_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_OTHER", VALUEFUNC(LiquidityIndType_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "LiquidityIndType_20DAY", VALUEFUNC(LiquidityIndType_20DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_IN_PROCESS", VALUEFUNC(StatusValue_IN_PROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOTCONNECTEDDOWNEXPECTEDUP", VALUEFUNC(StatusValue_NOTCONNECTEDDOWNEXPECTEDUP_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOT_CONNECTED_2", VALUEFUNC(StatusValue_NOT_CONNECTED_2_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN", VALUEFUNC(StatusValue_NOTCONNECTEDDOWNEXPECTEDDOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_CONNECTED", VALUEFUNC(StatusValue_CONNECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_NOT_CONNECTED_3", VALUEFUNC(StatusValue_NOT_CONNECTED_3_get), 0);
  rb_define_singleton_method(mQuickfix, "StatusValue_INPROCESS", VALUEFUNC(StatusValue_INPROCESS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTRA_SPREAD_QTY", VALUEFUNC(PosType_INTRA_SPREAD_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTER_SPREAD_QTY", VALUEFUNC(PosType_INTER_SPREAD_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSFER_TRADE_QTY", VALUEFUNC(PosType_TRANSFER_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_EXCHANGE_FOR_PHYSICAL_QTY", VALUEFUNC(PosType_EXCHANGE_FOR_PHYSICAL_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSFERTRADEQTY", VALUEFUNC(PosType_TRANSFERTRADEQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTIONQUANTITY", VALUEFUNC(PosType_TRANSACTIONQUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ADJUSTMENTQTY", VALUEFUNC(PosType_ADJUSTMENTQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_START_OF_DAY_QTY", VALUEFUNC(PosType_START_OF_DAY_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ENDOFDAYQTY", VALUEFUNC(PosType_ENDOFDAYQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_DELIVERY_QTY", VALUEFUNC(PosType_DELIVERY_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTIONFROMEXERCISE", VALUEFUNC(PosType_TRANSACTIONFROMEXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_OPTIONEXERCISEQTY", VALUEFUNC(PosType_OPTIONEXERCISEQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_DELIVERYQTY", VALUEFUNC(PosType_DELIVERYQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_OPTION_ASSIGNMENT", VALUEFUNC(PosType_OPTION_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_PIT_TRADE_QTY", VALUEFUNC(PosType_PIT_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTION_FROM_ASSIGNMENT", VALUEFUNC(PosType_TRANSACTION_FROM_ASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTION_FROM_EXERCISE", VALUEFUNC(PosType_TRANSACTION_FROM_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTEGRALSPLIT", VALUEFUNC(PosType_INTEGRALSPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ELECTRONICTRADEQTY", VALUEFUNC(PosType_ELECTRONICTRADEQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_AS_OF_TRADE_QTY", VALUEFUNC(PosType_AS_OF_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ELECTRONIC_TRADE_QTY", VALUEFUNC(PosType_ELECTRONIC_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_PITTRADEQTY", VALUEFUNC(PosType_PITTRADEQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_OPTIONASSIGNMENT", VALUEFUNC(PosType_OPTIONASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_SUCCESSION_EVENT_ADJUSTMENT", VALUEFUNC(PosType_SUCCESSION_EVENT_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_OPTION_EXERCISE_QTY", VALUEFUNC(PosType_OPTION_EXERCISE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTION_QUANTITY", VALUEFUNC(PosType_TRANSACTION_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_NET_DELTA_QTY", VALUEFUNC(PosType_NET_DELTA_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_END_OF_DAY_QTY", VALUEFUNC(PosType_END_OF_DAY_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ADJUSTMENT_QTY", VALUEFUNC(PosType_ADJUSTMENT_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TOTAL_TRANSACTION_QTY", VALUEFUNC(PosType_TOTAL_TRANSACTION_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_DELIVERY_NOTICE_QTY", VALUEFUNC(PosType_DELIVERY_NOTICE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_RECEIVE_QUANTITY", VALUEFUNC(PosType_RECEIVE_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ASOFTRADEQTY", VALUEFUNC(PosType_ASOFTRADEQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ALLOCATIONTRADEQTY", VALUEFUNC(PosType_ALLOCATIONTRADEQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_CREDIT_EVENT_ADJUSTMENT", VALUEFUNC(PosType_CREDIT_EVENT_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_PRIVATELY_NEGOTIATED_TRADE_QTY", VALUEFUNC(PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_CROSS_MARGIN_QTY", VALUEFUNC(PosType_CROSS_MARGIN_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_CORPORATE_ACTION_ADJUSTMENT", VALUEFUNC(PosType_CORPORATE_ACTION_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TOTALTRANSACTIONQTY", VALUEFUNC(PosType_TOTALTRANSACTIONQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_STARTOFDAYQTY", VALUEFUNC(PosType_STARTOFDAYQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTEGRAL_SPLIT", VALUEFUNC(PosType_INTEGRAL_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTERSPREADQTY", VALUEFUNC(PosType_INTERSPREADQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_INTRASPREADQTY", VALUEFUNC(PosType_INTRASPREADQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_ALLOCATION_TRADE_QTY", VALUEFUNC(PosType_ALLOCATION_TRADE_QTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_CROSSMARGINQTY", VALUEFUNC(PosType_CROSSMARGINQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosType_TRANSACTIONFROMASSIGNMENT", VALUEFUNC(PosType_TRANSACTIONFROMASSIGNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnAckType_ASSIGNMENT_REJECTED", VALUEFUNC(StreamAsgnAckType_ASSIGNMENT_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "StreamAsgnAckType_ASSIGNMENT_ACCEPTED", VALUEFUNC(StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "RiskInstrumentOperator_EXCLUDE", VALUEFUNC(RiskInstrumentOperator_EXCLUDE_get), 0);
  rb_define_singleton_method(mQuickfix, "RiskInstrumentOperator_INCLUDE", VALUEFUNC(RiskInstrumentOperator_INCLUDE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeBasis_PERUNIT", VALUEFUNC(MiscFeeBasis_PERUNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeBasis_ABSOLUTE", VALUEFUNC(MiscFeeBasis_ABSOLUTE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeBasis_PERCENTAGE", VALUEFUNC(MiscFeeBasis_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MiscFeeBasis_PER_UNIT", VALUEFUNC(MiscFeeBasis_PER_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_MARKET", VALUEFUNC(OrdType_FOREX_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_PREVIOUSLY_QUOTED", VALUEFUNC(OrdType_FOREX_PREVIOUSLY_QUOTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_ONBASIS", VALUEFUNC(OrdType_ONBASIS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUSLYINDICATED", VALUEFUNC(OrdType_PREVIOUSLYINDICATED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUS_FUND_VALUATION_POINT", VALUEFUNC(OrdType_PREVIOUS_FUND_VALUATION_POINT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PEGGED", VALUEFUNC(OrdType_PEGGED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMITONCLOSE", VALUEFUNC(OrdType_LIMITONCLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT_WITH_OR_WITHOUT", VALUEFUNC(OrdType_LIMIT_WITH_OR_WITHOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_STOP_LIMIT", VALUEFUNC(OrdType_STOP_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_SWAP", VALUEFUNC(OrdType_FOREX_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_WITHORWITHOUT", VALUEFUNC(OrdType_WITHORWITHOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREXLIMIT", VALUEFUNC(OrdType_FOREXLIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT", VALUEFUNC(OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUSLYQUOTED", VALUEFUNC(OrdType_PREVIOUSLYQUOTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUSLY_QUOTED", VALUEFUNC(OrdType_PREVIOUSLY_QUOTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_COUNTER_ORDER_SELECTION", VALUEFUNC(OrdType_COUNTER_ORDER_SELECTION_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMITWITHORWITHOUT", VALUEFUNC(OrdType_LIMITWITHORWITHOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREXSWAP", VALUEFUNC(OrdType_FOREXSWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_IF_TOUCHED", VALUEFUNC(OrdType_MARKET_IF_TOUCHED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_NEXT_FUND_VALUATION_POINT", VALUEFUNC(OrdType_NEXT_FUND_VALUATION_POINT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_C", VALUEFUNC(OrdType_FOREX_C_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_ON_CLOSE", VALUEFUNC(OrdType_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_STOP", VALUEFUNC(OrdType_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_STOPLIMIT", VALUEFUNC(OrdType_STOPLIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMITORBETTER", VALUEFUNC(OrdType_LIMITORBETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_ONCLOSE", VALUEFUNC(OrdType_ONCLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_LIMIT", VALUEFUNC(OrdType_FOREX_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREXMARKET", VALUEFUNC(OrdType_FOREXMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX", VALUEFUNC(OrdType_FOREX_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKETIFTOUCHED", VALUEFUNC(OrdType_MARKETIFTOUCHED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FUNARI", VALUEFUNC(OrdType_FUNARI_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_F", VALUEFUNC(OrdType_FOREX_F_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUSLY_INDICATED", VALUEFUNC(OrdType_PREVIOUSLY_INDICATED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_WITH_OR_WITHOUT", VALUEFUNC(OrdType_WITH_OR_WITHOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_ON_CLOSE", VALUEFUNC(OrdType_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT", VALUEFUNC(OrdType_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT", VALUEFUNC(OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_G", VALUEFUNC(OrdType_FOREX_G_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT_ON_CLOSE", VALUEFUNC(OrdType_LIMIT_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKETONCLOSE", VALUEFUNC(OrdType_MARKETONCLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_PREVIOUSFUNDVALUATIONPOINT", VALUEFUNC(OrdType_PREVIOUSFUNDVALUATIONPOINT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_NEXTFUNDVALUATIONPOINT", VALUEFUNC(OrdType_NEXTFUNDVALUATIONPOINT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREX_H", VALUEFUNC(OrdType_FOREX_H_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_FOREXPREVIOUSLYQUOTED", VALUEFUNC(OrdType_FOREXPREVIOUSLYQUOTED_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKETWITHLEFTOVERLIMIT", VALUEFUNC(OrdType_MARKETWITHLEFTOVERLIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_ON_BASIS", VALUEFUNC(OrdType_ON_BASIS_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_LIMIT_OR_BETTER", VALUEFUNC(OrdType_LIMIT_OR_BETTER_get), 0);
  rb_define_singleton_method(mQuickfix, "OrdType_MARKET", VALUEFUNC(OrdType_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_DEFAULT_AFTER_M2", VALUEFUNC(MatchType_ACT_DEFAULT_AFTER_M2_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZEDMATCHUSINGA2", VALUEFUNC(MatchType_SUMMARIZEDMATCHUSINGA2_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COUNTER_ORDER_SELECTION_6", VALUEFUNC(MatchType_COUNTER_ORDER_SELECTION_6_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND", VALUEFUNC(MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NON_ACT", VALUEFUNC(MatchType_NON_ACT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZEDMATCHUSINGA3", VALUEFUNC(MatchType_SUMMARIZEDMATCHUSINGA3_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH", VALUEFUNC(MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZEDMATCHUSINGA4", VALUEFUNC(MatchType_SUMMARIZEDMATCHUSINGA4_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT", VALUEFUNC(MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZEDMATCHUSINGA5", VALUEFUNC(MatchType_SUMMARIZEDMATCHUSINGA5_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NASDAQACTM2MATCH", VALUEFUNC(MatchType_NASDAQACTM2MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CROSS_AUCTION_5", VALUEFUNC(MatchType_CROSS_AUCTION_5_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_M1_MATCH", VALUEFUNC(MatchType_ACT_M1_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(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_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES", VALUEFUNC(MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGES_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NASDAQACTDEFAULTAFTERM2", VALUEFUNC(MatchType_NASDAQACTDEFAULTAFTERM2_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES", VALUEFUNC(MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGES_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NASDAQACTM1MATCH", VALUEFUNC(MatchType_NASDAQACTM1MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CALL_AUCTION_7", VALUEFUNC(MatchType_CALL_AUCTION_7_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CROSS_AUCTION_63", VALUEFUNC(MatchType_CROSS_AUCTION_63_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ISSUING_BUY_BACK_AUCTION", VALUEFUNC(MatchType_ISSUING_BUY_BACK_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_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(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_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME", VALUEFUNC(MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSFOURBADGESANDEXECUTIONTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ONE_PARTY_TRADE_REPORT", VALUEFUNC(MatchType_ONE_PARTY_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_M2_MATCH", VALUEFUNC(MatchType_ACT_M2_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES", VALUEFUNC(MatchType_SUMMARIZEDMATCHMINUSBADGESANDTIMES_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NASDAQACTDEFAULTTRADE", VALUEFUNC(MatchType_NASDAQACTDEFAULTTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CALL_AUCTION", VALUEFUNC(MatchType_CALL_AUCTION_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(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_ACT_ACCEPTED_TRADE", VALUEFUNC(MatchType_ACT_ACCEPTED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_TWO_PARTY_TRADE_REPORT", VALUEFUNC(MatchType_TWO_PARTY_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CONTINUOUS_AUTO_MATCH", VALUEFUNC(MatchType_CONTINUOUS_AUTO_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT", VALUEFUNC(MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_M6_MATCH", VALUEFUNC(MatchType_ACT_M6_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_ACT_DEFAULT_TRADE", VALUEFUNC(MatchType_ACT_DEFAULT_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES", VALUEFUNC(MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORMINUSBADGESANDTIMES_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST", VALUEFUNC(MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_AUTO_MATCH", VALUEFUNC(MatchType_AUTO_MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NASDAQACTM6MATCH", VALUEFUNC(MatchType_NASDAQACTM6MATCH_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_OCSLOCKEDIN", VALUEFUNC(MatchType_OCSLOCKEDIN_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COUNTER_ORDER_SELECTION", VALUEFUNC(MatchType_COUNTER_ORDER_SELECTION_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(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_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NASDAQACTACCEPTEDTRADE", VALUEFUNC(MatchType_NASDAQACTACCEPTEDTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CALL_AUCTION_65", VALUEFUNC(MatchType_CALL_AUCTION_65_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CROSS_AUCTION", VALUEFUNC(MatchType_CROSS_AUCTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_OCS_LOCKED_IN_NON_ACT", VALUEFUNC(MatchType_OCS_LOCKED_IN_NON_ACT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_CONFIRMED_TRADE_REPORT", VALUEFUNC(MatchType_CONFIRMED_TRADE_REPORT_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(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_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME", VALUEFUNC(MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSTWOBADGESANDEXECUTIONTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED", VALUEFUNC(MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME", VALUEFUNC(MatchType_EXACTMATCHONTRADEDATESTOCKSYMBOLQUANTITYPRICETRADETYPEANDSPECIALTRADEINDICATORPLUSEXECUTIONTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_NASDAQNONACT", VALUEFUNC(MatchType_NASDAQNONACT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS", VALUEFUNC(MatchType_COMPAREDRECORDSRESULTINGFROMSTAMPEDADVISORIESORSPECIALISTACCEPTSPAIROFFS_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(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_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS", VALUEFUNC(MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchType_SUMMARIZEDMATCHUSINGA1", VALUEFUNC(MatchType_SUMMARIZEDMATCHUSINGA1_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(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_COUNTER_ORDER_SELECTION_64", VALUEFUNC(MatchType_COUNTER_ORDER_SELECTION_64_get), 0);
  rb_define_singleton_method(mQuickfix, "OptPayoutType_BINARY", VALUEFUNC(OptPayoutType_BINARY_get), 0);
  rb_define_singleton_method(mQuickfix, "OptPayoutType_VANILLA", VALUEFUNC(OptPayoutType_VANILLA_get), 0);
  rb_define_singleton_method(mQuickfix, "OptPayoutType_CAPPED", VALUEFUNC(OptPayoutType_CAPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "MarketUpdateAction_DELETE", VALUEFUNC(MarketUpdateAction_DELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "MarketUpdateAction_ADD", VALUEFUNC(MarketUpdateAction_ADD_get), 0);
  rb_define_singleton_method(mQuickfix, "MarketUpdateAction_MODIFY", VALUEFUNC(MarketUpdateAction_MODIFY_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL", VALUEFUNC(CollAsgnRejectReason_INVALIDTYPEOFCOLLATERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION", VALUEFUNC(CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT", VALUEFUNC(CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNKNOWNDEAL", VALUEFUNC(CollAsgnRejectReason_UNKNOWNDEAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNKNOWN_DEAL", VALUEFUNC(CollAsgnRejectReason_UNKNOWN_DEAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION", VALUEFUNC(CollAsgnRejectReason_UNAUTHORIZEDTRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL", VALUEFUNC(CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_INSUFFICIENTCOLLATERAL", VALUEFUNC(CollAsgnRejectReason_INSUFFICIENTCOLLATERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT", VALUEFUNC(CollAsgnRejectReason_UNKNOWNORINVALIDINSTRUMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION", VALUEFUNC(CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_OTHER", VALUEFUNC(CollAsgnRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_INSUFFICIENT_COLLATERAL", VALUEFUNC(CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAsgnRejectReason_EXCESSIVESUBSTITUTION", VALUEFUNC(CollAsgnRejectReason_EXCESSIVESUBSTITUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "IndividualAllocType_SUB_ALLOCATE", VALUEFUNC(IndividualAllocType_SUB_ALLOCATE_get), 0);
  rb_define_singleton_method(mQuickfix, "IndividualAllocType_THIRD_PARTY_ALLOCATION", VALUEFUNC(IndividualAllocType_THIRD_PARTY_ALLOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMUNTILFILL", VALUEFUNC(GTBookingInst_ACCUMUNTILFILL_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMUNTILNOTIFY", VALUEFUNC(GTBookingInst_ACCUMUNTILNOTIFY_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION", VALUEFUNC(GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE", VALUEFUNC(GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES", VALUEFUNC(GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_BOOKALL", VALUEFUNC(GTBookingInst_BOOKALL_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE", VALUEFUNC(GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get), 0);
  rb_define_singleton_method(mQuickfix, "GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES", VALUEFUNC(GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_get), 0);
  rb_define_singleton_method(mQuickfix, "PutOrCall_PUT", VALUEFUNC(PutOrCall_PUT_get), 0);
  rb_define_singleton_method(mQuickfix, "PutOrCall_CALL", VALUEFUNC(PutOrCall_CALL_get), 0);
  rb_define_singleton_method(mQuickfix, "FundRenewWaiv_NO", VALUEFUNC(FundRenewWaiv_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "FundRenewWaiv_YES", VALUEFUNC(FundRenewWaiv_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ForexReq_NO", VALUEFUNC(ForexReq_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ForexReq_YES", VALUEFUNC(ForexReq_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_TRADED_AS_A_SPREAD_LEG", VALUEFUNC(TickRuleType_TRADED_AS_A_SPREAD_LEG_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_REGULAR", VALUEFUNC(TickRuleType_REGULAR_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_VARIABLE", VALUEFUNC(TickRuleType_VARIABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_SETTLED_AS_A_SPREAD_LEG", VALUEFUNC(TickRuleType_SETTLED_AS_A_SPREAD_LEG_get), 0);
  rb_define_singleton_method(mQuickfix, "TickRuleType_FIXED", VALUEFUNC(TickRuleType_FIXED_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_PRICE", VALUEFUNC(DiscretionOffsetType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_BASISPOINTS", VALUEFUNC(DiscretionOffsetType_BASISPOINTS_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_PRICE_TIER", VALUEFUNC(DiscretionOffsetType_PRICE_TIER_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_TICKS", VALUEFUNC(DiscretionOffsetType_TICKS_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_PRICETIERLEVEL", VALUEFUNC(DiscretionOffsetType_PRICETIERLEVEL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionOffsetType_BASIS_POINTS", VALUEFUNC(DiscretionOffsetType_BASIS_POINTS_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmTransType_REPLACE", VALUEFUNC(ConfirmTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmTransType_NEW", VALUEFUNC(ConfirmTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "ConfirmTransType_CANCEL", VALUEFUNC(ConfirmTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "MDSecSizeType_CUSTOMER", VALUEFUNC(MDSecSizeType_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_CHANGE_OF_TRADING_STATUS", VALUEFUNC(TradSesEvent_CHANGE_OF_TRADING_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_CHANGE_OF_TRADING_SESSION", VALUEFUNC(TradSesEvent_CHANGE_OF_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_CHANGE_OF_TRADING_SUBSESSION", VALUEFUNC(TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesEvent_TRADING_RESUMES", VALUEFUNC(TradSesEvent_TRADING_RESUMES_get), 0);
  rb_define_singleton_method(mQuickfix, "DlvyInstType_SECURITIES", VALUEFUNC(DlvyInstType_SECURITIES_get), 0);
  rb_define_singleton_method(mQuickfix, "DlvyInstType_CASH", VALUEFUNC(DlvyInstType_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMPLIED_TRADE", VALUEFUNC(TradeCondition_IMPLIED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CASHMKT", VALUEFUNC(TradeCondition_CASHMKT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENING_PRICE", VALUEFUNC(TradeCondition_OPENING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_PRIOR_REFERENCE_PRICE", VALUEFUNC(TradeCondition_PRIOR_REFERENCE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_LAST_ETH", VALUEFUNC(TradeCondition_CANCEL_LAST_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SELLER", VALUEFUNC(TradeCondition_SELLER_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_DISTRIBUTION", VALUEFUNC(TradeCondition_DISTRIBUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_NEXT_DAY_TRADE", VALUEFUNC(TradeCondition_NEXT_DAY_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STRADDLE_ETH", VALUEFUNC(TradeCondition_STRADDLE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SPREAD", VALUEFUNC(TradeCondition_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENINGPRICE", VALUEFUNC(TradeCondition_OPENINGPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CROSSED_AO", VALUEFUNC(TradeCondition_CROSSED_AO_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD_LAST_SALE", VALUEFUNC(TradeCondition_SOLD_LAST_SALE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENED_SALE_ETH", VALUEFUNC(TradeCondition_OPENED_SALE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_REOPEN_ETH", VALUEFUNC(TradeCondition_REOPEN_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD_LAST_SALE_ETH", VALUEFUNC(TradeCondition_SOLD_LAST_SALE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_SOLD_LAST", VALUEFUNC(TradeCondition_STOPPED_SOLD_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP", VALUEFUNC(TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_NEXTDAY_D", VALUEFUNC(TradeCondition_NEXTDAY_D_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_FORM_T", VALUEFUNC(TradeCondition_FORM_T_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_ADJUSTED", VALUEFUNC(TradeCondition_ADJUSTED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_ETH", VALUEFUNC(TradeCondition_CANCEL_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OUT_OF_SEQUENCE_ETH", VALUEFUNC(TradeCondition_OUT_OF_SEQUENCE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_RULE127", VALUEFUNC(TradeCondition_RULE127_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_COMBO_ETH", VALUEFUNC(TradeCondition_COMBO_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_ONLY_ETH", VALUEFUNC(TradeCondition_CANCEL_ONLY_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STRADDLE", VALUEFUNC(TradeCondition_STRADDLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OUTSIDE_SPREAD", VALUEFUNC(TradeCondition_OUTSIDE_SPREAD_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BUNCHED_SALE", VALUEFUNC(TradeCondition_BUNCHED_SALE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_STOPPED", VALUEFUNC(TradeCondition_CANCEL_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_LATE_OPEN_ETH", VALUEFUNC(TradeCondition_LATE_OPEN_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENING_REOPENING_TRADE_DETAIL", VALUEFUNC(TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL", VALUEFUNC(TradeCondition_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_COMBO", VALUEFUNC(TradeCondition_COMBO_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENING", VALUEFUNC(TradeCondition_OPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_ACQUISITION", VALUEFUNC(TradeCondition_ACQUISITION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OPENED", VALUEFUNC(TradeCondition_OPENED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_ONLY", VALUEFUNC(TradeCondition_CANCEL_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_NEXT_DAY", VALUEFUNC(TradeCondition_NEXT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BARGAIN_CONDITION", VALUEFUNC(TradeCondition_BARGAIN_CONDITION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED", VALUEFUNC(TradeCondition_STOPPED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CONVERTED_PRICE_INDICATOR", VALUEFUNC(TradeCondition_CONVERTED_PRICE_INDICATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OFFICIAL_CLOSING_PRICE", VALUEFUNC(TradeCondition_OFFICIAL_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_ADJUSTED_ETH", VALUEFUNC(TradeCondition_ADJUSTED_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_AVGPX", VALUEFUNC(TradeCondition_AVGPX_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_RULE_155_TRADE", VALUEFUNC(TradeCondition_RULE_155_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLDLAST", VALUEFUNC(TradeCondition_SOLDLAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_NEXTDAY_J", VALUEFUNC(TradeCondition_NEXTDAY_J_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_AUTOMATIC_EXECUTION", VALUEFUNC(TradeCondition_AUTOMATIC_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CROSSED_X", VALUEFUNC(TradeCondition_CROSSED_X_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_AUTO_EXECUTION_ETH", VALUEFUNC(TradeCondition_AUTO_EXECUTION_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_MULTILEG_TO_MULTILEG_TRADE", VALUEFUNC(TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_OFFICAL_CLOSING_PRICE", VALUEFUNC(TradeCondition_OFFICAL_CLOSING_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_FINAL_PRICE_OF_SESSION", VALUEFUNC(TradeCondition_FINAL_PRICE_OF_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BASKET_INDEX", VALUEFUNC(TradeCondition_BASKET_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE", VALUEFUNC(TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_STOCK", VALUEFUNC(TradeCondition_STOPPED_STOCK_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE", VALUEFUNC(TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_ETH", VALUEFUNC(TradeCondition_STOPPED_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_REGULAR_ETH", VALUEFUNC(TradeCondition_REGULAR_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_OPEN", VALUEFUNC(TradeCondition_CANCEL_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CASH", VALUEFUNC(TradeCondition_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CASHTRADE", VALUEFUNC(TradeCondition_CASHTRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_RULE155", VALUEFUNC(TradeCondition_RULE155_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_STOPPED_ETH", VALUEFUNC(TradeCondition_CANCEL_STOPPED_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_VOLUME_ONLY", VALUEFUNC(TradeCondition_VOLUME_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SPLIT_TRADE", VALUEFUNC(TradeCondition_SPLIT_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_STOPPED_OUT_OF_SEQUENCE", VALUEFUNC(TradeCondition_STOPPED_OUT_OF_SEQUENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CASH_TRADE", VALUEFUNC(TradeCondition_CASH_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMBALANCE_MORE_BUYERS", VALUEFUNC(TradeCondition_IMBALANCE_MORE_BUYERS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BUNCHED", VALUEFUNC(TradeCondition_BUNCHED_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_INTRADAY", VALUEFUNC(TradeCondition_INTRADAY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMBALANCE_MORE_SELLERS", VALUEFUNC(TradeCondition_IMBALANCE_MORE_SELLERS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_INTRADAY_TRADE_DETAIL", VALUEFUNC(TradeCondition_INTRADAY_TRADE_DETAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_RULE_127_TRADE", VALUEFUNC(TradeCondition_RULE_127_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMBALANCEMOREBUYERS", VALUEFUNC(TradeCondition_IMBALANCEMOREBUYERS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_REOPEN", VALUEFUNC(TradeCondition_REOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_EX_PIT", VALUEFUNC(TradeCondition_EX_PIT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_LAST", VALUEFUNC(TradeCondition_CANCEL_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_DIRECT_PLUS", VALUEFUNC(TradeCondition_DIRECT_PLUS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_IMBALANCEMORESELLERS", VALUEFUNC(TradeCondition_IMBALANCEMORESELLERS_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_AVERAGE_PRICE_TRADE", VALUEFUNC(TradeCondition_AVERAGE_PRICE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD_LAST", VALUEFUNC(TradeCondition_SOLD_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_MARKETPLACE_ENTERED_TRADE", VALUEFUNC(TradeCondition_MARKETPLACE_ENTERED_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SPREAD_ETH", VALUEFUNC(TradeCondition_SPREAD_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_CANCEL_OPEN_ETH", VALUEFUNC(TradeCondition_CANCEL_OPEN_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_EXCHANGE_LAST", VALUEFUNC(TradeCondition_EXCHANGE_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_FAST_MARKET", VALUEFUNC(TradeCondition_FAST_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_BURST_BASKET", VALUEFUNC(TradeCondition_BURST_BASKET_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeCondition_SOLD", VALUEFUNC(TradeCondition_SOLD_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceLimitType_PRICE", VALUEFUNC(PriceLimitType_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceLimitType_TICKS", VALUEFUNC(PriceLimitType_TICKS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriceLimitType_PERCENTAGE", VALUEFUNC(PriceLimitType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PER_SHARE", VALUEFUNC(CommType_PER_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PCTWAIVEDCSHDISC", VALUEFUNC(CommType_PCTWAIVEDCSHDISC_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_ABSOLUTE", VALUEFUNC(CommType_ABSOLUTE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PCTWAIVEDENUNITS", VALUEFUNC(CommType_PCTWAIVEDENUNITS_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERBOND", VALUEFUNC(CommType_PERBOND_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PER_BOND", VALUEFUNC(CommType_PER_BOND_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENTAGE", VALUEFUNC(CommType_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENTAGE_WAIVED_4", VALUEFUNC(CommType_PERCENTAGE_WAIVED_4_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_POINTS_PER_BOND_OR_CONTRACT", VALUEFUNC(CommType_POINTS_PER_BOND_OR_CONTRACT_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENTAGE_WAIVED_5", VALUEFUNC(CommType_PERCENTAGE_WAIVED_5_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PER_UNIT", VALUEFUNC(CommType_PER_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_PERCENT", VALUEFUNC(CommType_PERCENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_4", VALUEFUNC(CommType_4_get), 0);
  rb_define_singleton_method(mQuickfix, "CommType_5", VALUEFUNC(CommType_5_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDOWNERSHIPTYPE", VALUEFUNC(RegistRejReasonCode_INVALIDOWNERSHIPTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDREGDTLS", VALUEFUNC(RegistRejReasonCode_INVALIDREGDTLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDMAILINGDTLS", VALUEFUNC(RegistRejReasonCode_INVALIDMAILINGDTLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE", VALUEFUNC(RegistRejReasonCode_INVALIDINVESTORCOUNTRYOFRESIDENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE", VALUEFUNC(RegistRejReasonCode_INVALIDCASHDISTRIBAGENTCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDDATEOFBIRTH", VALUEFUNC(RegistRejReasonCode_INVALIDDATEOFBIRTH_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD", VALUEFUNC(RegistRejReasonCode_INVALIDDISTRIBPAYMENTMETHOD_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDNODISTRIBINSTNS", VALUEFUNC(RegistRejReasonCode_INVALIDNODISTRIBINSTNS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM", VALUEFUNC(RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNUM_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDTAXEXEMPTTYPE", VALUEFUNC(RegistRejReasonCode_INVALIDTAXEXEMPTTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDMAILINGINST", VALUEFUNC(RegistRejReasonCode_INVALIDMAILINGINST_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDACCOUNTTYPE", VALUEFUNC(RegistRejReasonCode_INVALIDACCOUNTTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDREGSEQNO", VALUEFUNC(RegistRejReasonCode_INVALIDREGSEQNO_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_OTHER", VALUEFUNC(RegistRejReasonCode_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE", VALUEFUNC(RegistRejReasonCode_INVALIDDISTRIBPERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDINVESTORIDSOURCE", VALUEFUNC(RegistRejReasonCode_INVALIDINVESTORIDSOURCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME", VALUEFUNC(RegistRejReasonCode_INVALIDCASHDISTRIBAGENTACCTNAME_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDNOREGDETLS", VALUEFUNC(RegistRejReasonCode_INVALIDNOREGDETLS_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALIDINVESTORID", VALUEFUNC(RegistRejReasonCode_INVALIDINVESTORID_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS", VALUEFUNC(RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_get), 0);
  rb_define_singleton_method(mQuickfix, "FinancialStatus_BANKRUPT", VALUEFUNC(FinancialStatus_BANKRUPT_get), 0);
  rb_define_singleton_method(mQuickfix, "FinancialStatus_PENDINGDELISTING", VALUEFUNC(FinancialStatus_PENDINGDELISTING_get), 0);
  rb_define_singleton_method(mQuickfix, "FinancialStatus_RESTRICTED", VALUEFUNC(FinancialStatus_RESTRICTED_get), 0);
  rb_define_singleton_method(mQuickfix, "FinancialStatus_PENDING_DELISTING", VALUEFUNC(FinancialStatus_PENDING_DELISTING_get), 0);
  rb_define_singleton_method(mQuickfix, "LastFragment_NO", VALUEFUNC(LastFragment_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LastFragment_YES", VALUEFUNC(LastFragment_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "NotifyBrokerOfCredit_NO", VALUEFUNC(NotifyBrokerOfCredit_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "NotifyBrokerOfCredit_YES", VALUEFUNC(NotifyBrokerOfCredit_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTERED_ADDRESS_12", VALUEFUNC(PartySubIDType_REGISTERED_ADDRESS_12_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CASH_ACCOUNT_NUMBER", VALUEFUNC(PartySubIDType_CASH_ACCOUNT_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FAX_NUMBER", VALUEFUNC(PartySubIDType_FAX_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CONTACTNAME", VALUEFUNC(PartySubIDType_CONTACTNAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES", VALUEFUNC(PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_DEPARTMENT", VALUEFUNC(PartySubIDType_DEPARTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CONTACT_NAME", VALUEFUNC(PartySubIDType_CONTACT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_TELEXNUMBER", VALUEFUNC(PartySubIDType_TELEXNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_PERSON", VALUEFUNC(PartySubIDType_PERSON_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FIRM", VALUEFUNC(PartySubIDType_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CASH_ACCOUNT_NAME", VALUEFUNC(PartySubIDType_CASH_ACCOUNT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_POSITION_ACCOUNT_TYPE", VALUEFUNC(PartySubIDType_POSITION_ACCOUNT_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_POSTAL_ADDRESS", VALUEFUNC(PartySubIDType_POSTAL_ADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITY_LOCATE_ID", VALUEFUNC(PartySubIDType_SECURITY_LOCATE_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_POSTALADDRESS", VALUEFUNC(PartySubIDType_POSTALADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FUND_ACCOUNT_NAME", VALUEFUNC(PartySubIDType_FUND_ACCOUNT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_PROFESSIONAL_CLIENT", VALUEFUNC(PartySubIDType_PROFESSIONAL_CLIENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_LOCATION", VALUEFUNC(PartySubIDType_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FULLLEGALNAMEOFFIRM", VALUEFUNC(PartySubIDType_FULLLEGALNAMEOFFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_LOCATIONDESK", VALUEFUNC(PartySubIDType_LOCATIONDESK_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTEREDADDRESS_12", VALUEFUNC(PartySubIDType_REGISTEREDADDRESS_12_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTRATION_NUMBER", VALUEFUNC(PartySubIDType_REGISTRATION_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_EMAILADDRESS", VALUEFUNC(PartySubIDType_EMAILADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SYSTEM", VALUEFUNC(PartySubIDType_SYSTEM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITIESACCOUNTNUMBER", VALUEFUNC(PartySubIDType_SECURITIESACCOUNTNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGULATORY_STATUS", VALUEFUNC(PartySubIDType_REGULATORY_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE", VALUEFUNC(PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_PHONENUMBER", VALUEFUNC(PartySubIDType_PHONENUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER", VALUEFUNC(PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTRATION_NAME", VALUEFUNC(PartySubIDType_REGISTRATION_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTERED_ADDRESS_18", VALUEFUNC(PartySubIDType_REGISTERED_ADDRESS_18_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_TELEX_NUMBER", VALUEFUNC(PartySubIDType_TELEX_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_EMAIL_ADDRESS", VALUEFUNC(PartySubIDType_EMAIL_ADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FAXNUMBER", VALUEFUNC(PartySubIDType_FAXNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_BIC", VALUEFUNC(PartySubIDType_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CASHACCOUNT", VALUEFUNC(PartySubIDType_CASHACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTRATIONNUMBER", VALUEFUNC(PartySubIDType_REGISTRATIONNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_LOCATION_DESK", VALUEFUNC(PartySubIDType_LOCATION_DESK_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_APPLICATION", VALUEFUNC(PartySubIDType_APPLICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CASHACCOUNTNAME", VALUEFUNC(PartySubIDType_CASHACCOUNTNAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITIES_ACCOUNT_NAME", VALUEFUNC(PartySubIDType_SECURITIES_ACCOUNT_NAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_PHONE_NUMBER", VALUEFUNC(PartySubIDType_PHONE_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITIESACCOUNTNAME", VALUEFUNC(PartySubIDType_SECURITIESACCOUNTNAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTRATIONNAME", VALUEFUNC(PartySubIDType_REGISTRATIONNAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_ELIGIBLE_COUNTERPARTY", VALUEFUNC(PartySubIDType_ELIGIBLE_COUNTERPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGISTEREDADDRESS_18", VALUEFUNC(PartySubIDType_REGISTEREDADDRESS_18_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_SECURITIES_ACCOUNT_NUMBER", VALUEFUNC(PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FULL_LEGAL_NAME_OF_FIRM", VALUEFUNC(PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_MARKET_MAKER", VALUEFUNC(PartySubIDType_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_EXECUTION_VENUE", VALUEFUNC(PartySubIDType_EXECUTION_VENUE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_POSITIONACCOUNTTYPE", VALUEFUNC(PartySubIDType_POSITIONACCOUNTTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_FUNDACCOUNTNAME", VALUEFUNC(PartySubIDType_FUNDACCOUNTNAME_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_CSDPARTICIPANTMEMBERCODE", VALUEFUNC(PartySubIDType_CSDPARTICIPANTMEMBERCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartySubIDType_REGULATORYSTATUS", VALUEFUNC(PartySubIDType_REGULATORYSTATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocNoOrdersType_EXPLICIT_LIST_PROVIDED", VALUEFUNC(AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocNoOrdersType_NOTSPECIFIED", VALUEFUNC(AllocNoOrdersType_NOTSPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocNoOrdersType_NOT_SPECIFIED", VALUEFUNC(AllocNoOrdersType_NOT_SPECIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocNoOrdersType_EXPLICITLISTPROVIDED", VALUEFUNC(AllocNoOrdersType_EXPLICITLISTPROVIDED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_FX_SWAP", VALUEFUNC(AllocLinkType_FX_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_F_X_NETTING", VALUEFUNC(AllocLinkType_F_X_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_FXNETTING", VALUEFUNC(AllocLinkType_FXNETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_FX_NETTING", VALUEFUNC(AllocLinkType_FX_NETTING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_FXSWAP", VALUEFUNC(AllocLinkType_FXSWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocLinkType_F_X_SWAP", VALUEFUNC(AllocLinkType_F_X_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingSettlementType_T_PLUS_1", VALUEFUNC(UnderlyingSettlementType_T_PLUS_1_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingSettlementType_T_PLUS_3", VALUEFUNC(UnderlyingSettlementType_T_PLUS_3_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingSettlementType_T_PLUS_4", VALUEFUNC(UnderlyingSettlementType_T_PLUS_4_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_NEW", VALUEFUNC(DisplayMethod_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_UNDISCLOSED", VALUEFUNC(DisplayMethod_UNDISCLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_RANDOM", VALUEFUNC(DisplayMethod_RANDOM_get), 0);
  rb_define_singleton_method(mQuickfix, "DisplayMethod_INITIAL", VALUEFUNC(DisplayMethod_INITIAL_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_PARTIALLY_ASSIGNED", VALUEFUNC(CollStatus_PARTIALLY_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_ASSIGNEDACCEPTED", VALUEFUNC(CollStatus_ASSIGNEDACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_ASSIGNMENT_PROPOSED", VALUEFUNC(CollStatus_ASSIGNMENT_PROPOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_ASSIGNED", VALUEFUNC(CollStatus_ASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_CHALLENGED", VALUEFUNC(CollStatus_CHALLENGED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_UNASSIGNED", VALUEFUNC(CollStatus_UNASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_ASSIGNMENTPROPOSED", VALUEFUNC(CollStatus_ASSIGNMENTPROPOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollStatus_PARTIALLYASSIGNED", VALUEFUNC(CollStatus_PARTIALLYASSIGNED_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDEVALUE_2", VALUEFUNC(SideValueInd_SIDEVALUE_2_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDEVALUE1", VALUEFUNC(SideValueInd_SIDEVALUE1_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDEVALUE2", VALUEFUNC(SideValueInd_SIDEVALUE2_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDE_VALUE_1", VALUEFUNC(SideValueInd_SIDE_VALUE_1_get), 0);
  rb_define_singleton_method(mQuickfix, "SideValueInd_SIDE_VALUE_2", VALUEFUNC(SideValueInd_SIDE_VALUE_2_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgDirection_RECEIVE", VALUEFUNC(MsgDirection_RECEIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "MsgDirection_SEND", VALUEFUNC(MsgDirection_SEND_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_DELETE", VALUEFUNC(MDUpdateAction_DELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_NEW", VALUEFUNC(MDUpdateAction_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_DELETE_THRU", VALUEFUNC(MDUpdateAction_DELETE_THRU_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_DELETE_FROM", VALUEFUNC(MDUpdateAction_DELETE_FROM_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_OVERLAY", VALUEFUNC(MDUpdateAction_OVERLAY_get), 0);
  rb_define_singleton_method(mQuickfix, "MDUpdateAction_CHANGE", VALUEFUNC(MDUpdateAction_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_ADVALERT", VALUEFUNC(MatchStatus_ADVALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED", VALUEFUNC(MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_COMPARED_MATCHED_OR_AFFIRMED", VALUEFUNC(MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_ADVISORY_OR_ALERT", VALUEFUNC(MatchStatus_ADVISORY_OR_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_UNCOMPUNMATUNAFF", VALUEFUNC(MatchStatus_UNCOMPUNMATUNAFF_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_COMPMATAFF", VALUEFUNC(MatchStatus_COMPMATAFF_get), 0);
  rb_define_singleton_method(mQuickfix, "MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED", VALUEFUNC(MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_REUTERS", VALUEFUNC(RateSource_REUTERS_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_OTHER", VALUEFUNC(RateSource_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_BLOOMBERG", VALUEFUNC(RateSource_BLOOMBERG_get), 0);
  rb_define_singleton_method(mQuickfix, "RateSource_TELERATE", VALUEFUNC(RateSource_TELERATE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_CLOSE", VALUEFUNC(AllocPositionEffect_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_FIFO", VALUEFUNC(AllocPositionEffect_FIFO_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_OPEN", VALUEFUNC(AllocPositionEffect_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocPositionEffect_ROLLED", VALUEFUNC(AllocPositionEffect_ROLLED_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER", VALUEFUNC(PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_PROPRIETARY", VALUEFUNC(PartyIDSource_PROPRIETARY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_USEMPLOYERIDNUMBER", VALUEFUNC(PartyIDSource_USEMPLOYERIDNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_ACCPTMARKETPART", VALUEFUNC(PartyIDSource_ACCPTMARKETPART_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CSDPARTCODE", VALUEFUNC(PartyIDSource_CSDPARTCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER", VALUEFUNC(PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_KOREANINVESTORID", VALUEFUNC(PartyIDSource_KOREANINVESTORID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER", VALUEFUNC(PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER", VALUEFUNC(PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER", VALUEFUNC(PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_AUSTRALIANTAXFILENUMBER", VALUEFUNC(PartyIDSource_AUSTRALIANTAXFILENUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESE_TRADING_ACCOUNT", VALUEFUNC(PartyIDSource_TAIWANESE_TRADING_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESE_TRADING_ACCT", VALUEFUNC(PartyIDSource_TAIWANESE_TRADING_ACCT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CHINESEBSHARE", VALUEFUNC(PartyIDSource_CHINESEBSHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_AUSTRALIANBUSINESSNUMBER", VALUEFUNC(PartyIDSource_AUSTRALIANBUSINESSNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY", VALUEFUNC(PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_US_SOCIAL_SECURITY_NUMBER", VALUEFUNC(PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESEQUALIFIED", VALUEFUNC(PartyIDSource_TAIWANESEQUALIFIED_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_USSOCIALSECURITY", VALUEFUNC(PartyIDSource_USSOCIALSECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_DIRECTEDDEFINEDISITC", VALUEFUNC(PartyIDSource_DIRECTEDDEFINEDISITC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER", VALUEFUNC(PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE", VALUEFUNC(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(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(PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_SETTLEMENT_ENTITY_LOCATION", VALUEFUNC(PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_PROPRIETARY_CUSTOM_CODE", VALUEFUNC(PartyIDSource_PROPRIETARY_CUSTOM_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_UKNATIONALINSPENNUMBER", VALUEFUNC(PartyIDSource_UKNATIONALINSPENNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_BIC", VALUEFUNC(PartyIDSource_BIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CHINESE_INVESTOR_ID", VALUEFUNC(PartyIDSource_CHINESE_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESETRADINGACCT", VALUEFUNC(PartyIDSource_TAIWANESETRADINGACCT_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_MIC", VALUEFUNC(PartyIDSource_MIC_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_KOREAN_INVESTOR_ID", VALUEFUNC(PartyIDSource_KOREAN_INVESTOR_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_ISO_COUNTRY_CODE", VALUEFUNC(PartyIDSource_ISO_COUNTRY_CODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID", VALUEFUNC(PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_PROPCODE", VALUEFUNC(PartyIDSource_PROPCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_ISOCODE", VALUEFUNC(PartyIDSource_ISOCODE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_CHINESE_B_SHARE", VALUEFUNC(PartyIDSource_CHINESE_B_SHARE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_MCDNUMBER", VALUEFUNC(PartyIDSource_MCDNUMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyIDSource_SETTLENTLOC", VALUEFUNC(PartyIDSource_SETTLENTLOC_get), 0);
  rb_define_singleton_method(mQuickfix, "ExchangeForPhysical_NO", VALUEFUNC(ExchangeForPhysical_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ExchangeForPhysical_YES", VALUEFUNC(ExchangeForPhysical_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS", VALUEFUNC(SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_TRADING_SESSION", VALUEFUNC(SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS", VALUEFUNC(SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION", VALUEFUNC(SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_BOOK_TYPE", VALUEFUNC(SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION", VALUEFUNC(SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH", VALUEFUNC(SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_TRADING_RESUMES", VALUEFUNC(SecurityTradingEvent_TRADING_RESUMES_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED", VALUEFUNC(SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAction_ADD", VALUEFUNC(CollAction_ADD_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAction_REMOVE", VALUEFUNC(CollAction_REMOVE_get), 0);
  rb_define_singleton_method(mQuickfix, "CollAction_RETAIN", VALUEFUNC(CollAction_RETAIN_get), 0);
  rb_define_singleton_method(mQuickfix, "PossDupFlag_NO", VALUEFUNC(PossDupFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "PossDupFlag_YES", VALUEFUNC(PossDupFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ALL_DONE", VALUEFUNC(ListStatusType_ALL_DONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_TIMED", VALUEFUNC(ListStatusType_TIMED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_RESP", VALUEFUNC(ListStatusType_RESP_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_EXECSTARTED", VALUEFUNC(ListStatusType_EXECSTARTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_RESPONSE", VALUEFUNC(ListStatusType_RESPONSE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ALLDONE", VALUEFUNC(ListStatusType_ALLDONE_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ALERT", VALUEFUNC(ListStatusType_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_ACK", VALUEFUNC(ListStatusType_ACK_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_EXEC_STARTED", VALUEFUNC(ListStatusType_EXEC_STARTED_get), 0);
  rb_define_singleton_method(mQuickfix, "ListStatusType_EXECSTART", VALUEFUNC(ListStatusType_EXECSTART_get), 0);
  rb_define_singleton_method(mQuickfix, "GapFillFlag_NO", VALUEFUNC(GapFillFlag_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "GapFillFlag_YES", VALUEFUNC(GapFillFlag_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING", VALUEFUNC(TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_TWO_PARTY_REPORT", VALUEFUNC(TradeHandlingInstr_TWO_PARTY_REPORT_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING", VALUEFUNC(TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_TRADE_CONFIRMATION", VALUEFUNC(TradeHandlingInstr_TRADE_CONFIRMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH", VALUEFUNC(TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM", VALUEFUNC(TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_TWOPARTY", VALUEFUNC(TradSesMethod_TWOPARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_ELECTRONIC", VALUEFUNC(TradSesMethod_ELECTRONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_OPENOUTCRY", VALUEFUNC(TradSesMethod_OPENOUTCRY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_TWO_PARTY", VALUEFUNC(TradSesMethod_TWO_PARTY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradSesMethod_OPEN_OUTCRY", VALUEFUNC(TradSesMethod_OPEN_OUTCRY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_AGENCY", VALUEFUNC(TradeType_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_VWAP_GUARANTEE", VALUEFUNC(TradeType_VWAP_GUARANTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_RISK_TRADE", VALUEFUNC(TradeType_RISK_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "TradeType_GUARANTEED_CLOSE", VALUEFUNC(TradeType_GUARANTEED_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventCondition_AND", VALUEFUNC(ComplexEventCondition_AND_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventCondition_OR", VALUEFUNC(ComplexEventCondition_OR_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_SONIA", VALUEFUNC(BenchmarkCurveName_SONIA_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_MUNIAAA", VALUEFUNC(BenchmarkCurveName_MUNIAAA_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_LIBID", VALUEFUNC(BenchmarkCurveName_LIBID_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_PFANDBRIEFE", VALUEFUNC(BenchmarkCurveName_PFANDBRIEFE_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_EUREPO", VALUEFUNC(BenchmarkCurveName_EUREPO_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_FUTURESWAP", VALUEFUNC(BenchmarkCurveName_FUTURESWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_TREASURY", VALUEFUNC(BenchmarkCurveName_TREASURY_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_OTHER", VALUEFUNC(BenchmarkCurveName_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_EURIBOR", VALUEFUNC(BenchmarkCurveName_EURIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_EONIA", VALUEFUNC(BenchmarkCurveName_EONIA_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_LIBOR", VALUEFUNC(BenchmarkCurveName_LIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "BenchmarkCurveName_SWAP", VALUEFUNC(BenchmarkCurveName_SWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_MARGINCLOSE", VALUEFUNC(CashMargin_MARGINCLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_MARGINOPEN", VALUEFUNC(CashMargin_MARGINOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_MARGIN_CLOSE", VALUEFUNC(CashMargin_MARGIN_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_MARGIN_OPEN", VALUEFUNC(CashMargin_MARGIN_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "CashMargin_CASH", VALUEFUNC(CashMargin_CASH_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_REPLACE", VALUEFUNC(SettlObligTransType_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_NEW", VALUEFUNC(SettlObligTransType_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_RESTATE", VALUEFUNC(SettlObligTransType_RESTATE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlObligTransType_CANCEL", VALUEFUNC(SettlObligTransType_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_PEGGED", VALUEFUNC(DeskOrderHandlingInst_PEGGED_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_ON_OPEN", VALUEFUNC(DeskOrderHandlingInst_MARKET_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_SCALE", VALUEFUNC(DeskOrderHandlingInst_SCALE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_FILL_OR_KILL", VALUEFUNC(DeskOrderHandlingInst_FILL_OR_KILL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_ALL_OR_NONE", VALUEFUNC(DeskOrderHandlingInst_ALL_OR_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_NOT_HELD", VALUEFUNC(DeskOrderHandlingInst_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_DIRECTED_ORDER", VALUEFUNC(DeskOrderHandlingInst_DIRECTED_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_STOP_STOCK_TRANSACTION", VALUEFUNC(DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_OVER_THE_DAY", VALUEFUNC(DeskOrderHandlingInst_OVER_THE_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_ADD_ON_ORDER", VALUEFUNC(DeskOrderHandlingInst_ADD_ON_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_AT_CLOSE", VALUEFUNC(DeskOrderHandlingInst_MARKET_AT_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_LIMIT_ON_OPEN", VALUEFUNC(DeskOrderHandlingInst_LIMIT_ON_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_CASH_NOT_HELD", VALUEFUNC(DeskOrderHandlingInst_CASH_NOT_HELD_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_ON_CLOSE", VALUEFUNC(DeskOrderHandlingInst_MARKET_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_TIME_ORDER", VALUEFUNC(DeskOrderHandlingInst_TIME_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_LIMIT_ON_CLOSE", VALUEFUNC(DeskOrderHandlingInst_LIMIT_ON_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL", VALUEFUNC(DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_TRAILING_STOP", VALUEFUNC(DeskOrderHandlingInst_TRAILING_STOP_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_WORK", VALUEFUNC(DeskOrderHandlingInst_WORK_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_RESERVE_SIZE_ORDER", VALUEFUNC(DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MINIMUM_QUANTITY", VALUEFUNC(DeskOrderHandlingInst_MINIMUM_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_MARKET_AT_OPEN", VALUEFUNC(DeskOrderHandlingInst_MARKET_AT_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_IMBALANCE_ONLY", VALUEFUNC(DeskOrderHandlingInst_IMBALANCE_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION", VALUEFUNC(DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_DO_NOT_EXERCISE", VALUEFUNC(PosTransType_DO_NOT_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION", VALUEFUNC(PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_DONOTEXERCISE", VALUEFUNC(PosTransType_DONOTEXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_LARGE_TRADER_SUBMISSION", VALUEFUNC(PosTransType_LARGE_TRADER_SUBMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION", VALUEFUNC(PosTransType_POSITIONCHANGESUBMISSIONMARGINDISPOSITION_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_POSITIONADJUSTMENT", VALUEFUNC(PosTransType_POSITIONADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_EXERCISE", VALUEFUNC(PosTransType_EXERCISE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_POSITION_ADJUSTMENT", VALUEFUNC(PosTransType_POSITION_ADJUSTMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosTransType_PLEDGE", VALUEFUNC(PosTransType_PLEDGE_get), 0);
  rb_define_singleton_method(mQuickfix, "Seniority_SUBORDINATED", VALUEFUNC(Seniority_SUBORDINATED_get), 0);
  rb_define_singleton_method(mQuickfix, "Seniority_SENIOR_SECURED", VALUEFUNC(Seniority_SENIOR_SECURED_get), 0);
  rb_define_singleton_method(mQuickfix, "Seniority_SENIOR", VALUEFUNC(Seniority_SENIOR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlCurrFxRateCalc_DIVIDE", VALUEFUNC(SettlCurrFxRateCalc_DIVIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlCurrFxRateCalc_MULTIPLY", VALUEFUNC(SettlCurrFxRateCalc_MULTIPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_ACCEPTED_WITH_WARNINGS", VALUEFUNC(PosMaintStatus_ACCEPTED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_COMPLETED", VALUEFUNC(PosMaintStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_ACCEPTEDWITHWARNINGS", VALUEFUNC(PosMaintStatus_ACCEPTEDWITHWARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_COMPLETEDWITHWARNINGS", VALUEFUNC(PosMaintStatus_COMPLETEDWITHWARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_REJECTED", VALUEFUNC(PosMaintStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_ACCEPTED", VALUEFUNC(PosMaintStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintStatus_COMPLETED_WITH_WARNINGS", VALUEFUNC(PosMaintStatus_COMPLETED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_6_MO_LIBOR", VALUEFUNC(Benchmark_6_MO_LIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD_5", VALUEFUNC(Benchmark_OLD_5_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD_30", VALUEFUNC(Benchmark_OLD_30_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_30YR", VALUEFUNC(Benchmark_30YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_5YR", VALUEFUNC(Benchmark_5YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_3_MO_LIBOR", VALUEFUNC(Benchmark_3_MO_LIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD_10", VALUEFUNC(Benchmark_OLD_10_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_6MOLIBOR", VALUEFUNC(Benchmark_6MOLIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_10YR", VALUEFUNC(Benchmark_10YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_CURVE", VALUEFUNC(Benchmark_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_30_YR", VALUEFUNC(Benchmark_30_YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_10_YR", VALUEFUNC(Benchmark_10_YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_5_YR", VALUEFUNC(Benchmark_5_YR_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD30", VALUEFUNC(Benchmark_OLD30_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD5", VALUEFUNC(Benchmark_OLD5_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_OLD10", VALUEFUNC(Benchmark_OLD10_get), 0);
  rb_define_singleton_method(mQuickfix, "Benchmark_3MOLIBOR", VALUEFUNC(Benchmark_3MOLIBOR_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearFormat_YEARMONTHWEEK", VALUEFUNC(MaturityMonthYearFormat_YEARMONTHWEEK_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearFormat_YEARMONTHDAY", VALUEFUNC(MaturityMonthYearFormat_YEARMONTHDAY_get), 0);
  rb_define_singleton_method(mQuickfix, "MaturityMonthYearFormat_YEARMONTH_ONLY", VALUEFUNC(MaturityMonthYearFormat_YEARMONTH_ONLY_get), 0);
  rb_define_singleton_method(mQuickfix, "LegalConfirm_NO", VALUEFUNC(LegalConfirm_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "LegalConfirm_YES", VALUEFUNC(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(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(ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM", VALUEFUNC(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(ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_get), 0);
  rb_define_singleton_method(mQuickfix, "ReportToExch_NO", VALUEFUNC(ReportToExch_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "ReportToExch_YES", VALUEFUNC(ReportToExch_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_ALLOCATED_QUANTITY", VALUEFUNC(AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWNACCT", VALUEFUNC(AllocRejCode_UNKNOWNACCT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECTAVGPRC", VALUEFUNC(AllocRejCode_INCORRECTAVGPRC_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_ORDERID", VALUEFUNC(AllocRejCode_UNKNOWN_ORDERID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_WAREHOUSEREQUESTREJECTED", VALUEFUNC(AllocRejCode_WAREHOUSEREQUESTREJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWNORSTALEEXECID", VALUEFUNC(AllocRejCode_UNKNOWNORSTALEEXECID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_WAREHOUSE_REQUEST_REJECTED", VALUEFUNC(AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_AVERAGEG_PRICE", VALUEFUNC(AllocRejCode_INCORRECT_AVERAGEG_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_MISMATCHEDDATA", VALUEFUNC(AllocRejCode_MISMATCHEDDATA_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECTBRKMNC", VALUEFUNC(AllocRejCode_INCORRECTBRKMNC_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWNLISTID", VALUEFUNC(AllocRejCode_UNKNOWNLISTID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_OTHER_99", VALUEFUNC(AllocRejCode_OTHER_99_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECTALLOCATEDQUANTITY", VALUEFUNC(AllocRejCode_INCORRECTALLOCATEDQUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_LISTID", VALUEFUNC(AllocRejCode_UNKNOWN_LISTID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_QUANTITY", VALUEFUNC(AllocRejCode_INCORRECT_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECT_AVERAGE_PRICE", VALUEFUNC(AllocRejCode_INCORRECT_AVERAGE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_ACCOUNT", VALUEFUNC(AllocRejCode_UNKNOWN_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_OR_STALE_EXECID", VALUEFUNC(AllocRejCode_UNKNOWN_OR_STALE_EXECID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_OTHER", VALUEFUNC(AllocRejCode_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_OTHER_7", VALUEFUNC(AllocRejCode_OTHER_7_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_CLORDID", VALUEFUNC(AllocRejCode_UNKNOWN_CLORDID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_INCORRECTQTY", VALUEFUNC(AllocRejCode_INCORRECTQTY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_COMMDIFF", VALUEFUNC(AllocRejCode_COMMDIFF_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_CALCULATIONDIFFERENCE", VALUEFUNC(AllocRejCode_CALCULATIONDIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWNCLORDID", VALUEFUNC(AllocRejCode_UNKNOWNCLORDID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWNORDID", VALUEFUNC(AllocRejCode_UNKNOWNORDID_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_MISMATCHED_DATA", VALUEFUNC(AllocRejCode_MISMATCHED_DATA_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_CALCULATION_DIFFERENCE", VALUEFUNC(AllocRejCode_CALCULATION_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_COMMISSION_DIFFERENCE", VALUEFUNC(AllocRejCode_COMMISSION_DIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC", VALUEFUNC(AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrdIDReason_GTC_FROM_PREVIOUS_DAY", VALUEFUNC(RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrdIDReason_PARTIAL_FILL_REMAINING", VALUEFUNC(RefOrdIDReason_PARTIAL_FILL_REMAINING_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrdIDReason_ORDER_CHANGED", VALUEFUNC(RefOrdIDReason_ORDER_CHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_SECONDARYORDERID", VALUEFUNC(RefOrderIDSource_SECONDARYORDERID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_ORDERID", VALUEFUNC(RefOrderIDSource_ORDERID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_MDENTRYID", VALUEFUNC(RefOrderIDSource_MDENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_ORIGINAL_ORDER_ID", VALUEFUNC(RefOrderIDSource_ORIGINAL_ORDER_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_MENTRYID", VALUEFUNC(RefOrderIDSource_MENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_QUOTEENTRYID", VALUEFUNC(RefOrderIDSource_QUOTEENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_QUOTENTRYID", VALUEFUNC(RefOrderIDSource_QUOTENTRYID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_ORDEID", VALUEFUNC(RefOrderIDSource_ORDEID_get), 0);
  rb_define_singleton_method(mQuickfix, "RefOrderIDSource_SECONDARYORDEID", VALUEFUNC(RefOrderIDSource_SECONDARYORDEID_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_A", VALUEFUNC(LastCapacity_A_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_XP", VALUEFUNC(LastCapacity_XP_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_CROSS_AS_PRINCIPAL", VALUEFUNC(LastCapacity_CROSS_AS_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_PRINCIPAL", VALUEFUNC(LastCapacity_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_P", VALUEFUNC(LastCapacity_P_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_CROSS_AS_AGENT", VALUEFUNC(LastCapacity_CROSS_AS_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_AGENT", VALUEFUNC(LastCapacity_AGENT_get), 0);
  rb_define_singleton_method(mQuickfix, "LastCapacity_XA", VALUEFUNC(LastCapacity_XA_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_STRIKE_PRICE", VALUEFUNC(InstrAttribType_INSTRUMENT_STRIKE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_IN_DEFAULT", VALUEFUNC(InstrAttribType_IN_DEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_COUPONPERIOD", VALUEFUNC(InstrAttribType_COUPONPERIOD_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ORIGINAL_ISSUE_DISCOUNT", VALUEFUNC(InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_PRE_REFUNDED", VALUEFUNC(InstrAttribType_PRE_REFUNDED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX", VALUEFUNC(InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLEPUTTABLE", VALUEFUNC(InstrAttribType_CALLABLEPUTTABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_WHEN_AND_IF_ISSUED", VALUEFUNC(InstrAttribType_WHEN_AND_IF_ISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_STEPPEDCOUPON", VALUEFUNC(InstrAttribType_STEPPEDCOUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_UNRATED", VALUEFUNC(InstrAttribType_UNRATED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED", VALUEFUNC(InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_STEPPED_COUPON", VALUEFUNC(InstrAttribType_STEPPED_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TEXT", VALUEFUNC(InstrAttribType_TEXT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ORIGINALISSUEDISCOUNTPRICE", VALUEFUNC(InstrAttribType_ORIGINALISSUEDISCOUNTPRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ESCROWEDTOREDEMPTIONDATE", VALUEFUNC(InstrAttribType_ESCROWEDTOREDEMPTIONDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_DENOMINATOR", VALUEFUNC(InstrAttribType_INSTRUMENT_DENOMINATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ESCROWED_TO_REDEMPTION_DATE", VALUEFUNC(InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INTEREST_BEARING", VALUEFUNC(InstrAttribType_INTEREST_BEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TAXABLE", VALUEFUNC(InstrAttribType_TAXABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLE_PUTTABLE", VALUEFUNC(InstrAttribType_CALLABLE_PUTTABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE", VALUEFUNC(InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_COUPON_PERIOD", VALUEFUNC(InstrAttribType_COUPON_PERIOD_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_LESSFEEFORPUT", VALUEFUNC(InstrAttribType_LESSFEEFORPUT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INTERESTBEARING", VALUEFUNC(InstrAttribType_INTERESTBEARING_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_PREREFUNDED", VALUEFUNC(InstrAttribType_PREREFUNDED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_PRICE_PRECISION", VALUEFUNC(InstrAttribType_INSTRUMENT_PRICE_PRECISION_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TRADEABLE_INDICATOR", VALUEFUNC(InstrAttribType_TRADEABLE_INDICATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE", VALUEFUNC(InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_VARIABLE_RATE", VALUEFUNC(InstrAttribType_VARIABLE_RATE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_WHENISSUED", VALUEFUNC(InstrAttribType_WHENISSUED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ZEROCOUPON", VALUEFUNC(InstrAttribType_ZEROCOUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX", VALUEFUNC(InstrAttribType_SUBJECTTOALTERNATIVEMINIMUMTAX_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ESCROWEDTOMATURITY", VALUEFUNC(InstrAttribType_ESCROWEDTOMATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_FLAT", VALUEFUNC(InstrAttribType_FLAT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY", VALUEFUNC(InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INSTRUMENT_NUMERATOR", VALUEFUNC(InstrAttribType_INSTRUMENT_NUMERATOR_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ESCROWED_TO_MATURITY", VALUEFUNC(InstrAttribType_ESCROWED_TO_MATURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_LESS_FEE_FOR_PUT", VALUEFUNC(InstrAttribType_LESS_FEE_FOR_PUT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE", VALUEFUNC(InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED", VALUEFUNC(InstrAttribType_CALLABLEWITHOUTNOTICEBYMAILTOHOLDERUNLESSREGISTERED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INDEXED", VALUEFUNC(InstrAttribType_INDEXED_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_INDEFAULT", VALUEFUNC(InstrAttribType_INDEFAULT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ZERO_COUPON", VALUEFUNC(InstrAttribType_ZERO_COUPON_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_NOPERIODICPAYMENTS", VALUEFUNC(InstrAttribType_NOPERIODICPAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_CALLABLEBELOWMATURITYVALUE", VALUEFUNC(InstrAttribType_CALLABLEBELOWMATURITYVALUE_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_ORIGINALISSUEDISCOUNT", VALUEFUNC(InstrAttribType_ORIGINALISSUEDISCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY", VALUEFUNC(InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_NO_PERIODIC_PAYMENTS", VALUEFUNC(InstrAttribType_NO_PERIODIC_PAYMENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "InstrAttribType_VARIABLERATE", VALUEFUNC(InstrAttribType_VARIABLERATE_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_FINANCING", VALUEFUNC(Product_FINANCING_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_COMMODITY", VALUEFUNC(Product_COMMODITY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_EQUITY", VALUEFUNC(Product_EQUITY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_CORPORATE", VALUEFUNC(Product_CORPORATE_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_AGENCY", VALUEFUNC(Product_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_OTHER", VALUEFUNC(Product_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_MONEYMARKET", VALUEFUNC(Product_MONEYMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_MORTGAGE", VALUEFUNC(Product_MORTGAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_CURRENCY", VALUEFUNC(Product_CURRENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_INDEX", VALUEFUNC(Product_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_MUNICIPAL", VALUEFUNC(Product_MUNICIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_LOAN", VALUEFUNC(Product_LOAN_get), 0);
  rb_define_singleton_method(mQuickfix, "Product_GOVERNMENT", VALUEFUNC(Product_GOVERNMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOMKTIMB", VALUEFUNC(SecurityTradingStatus_NOMKTIMB_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOOPEN", VALUEFUNC(SecurityTradingStatus_NOOPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_FAST_MARKET", VALUEFUNC(SecurityTradingStatus_FAST_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_OPEN_NO_RESUME", VALUEFUNC(SecurityTradingStatus_NO_OPEN_NO_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRADING_HALT", VALUEFUNC(SecurityTradingStatus_TRADING_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING", VALUEFUNC(SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_11", VALUEFUNC(SecurityTradingStatus_11_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_OPEN", VALUEFUNC(SecurityTradingStatus_NO_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOTTRADED", VALUEFUNC(SecurityTradingStatus_NOTTRADED_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_FASTMARKET", VALUEFUNC(SecurityTradingStatus_FASTMARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MKTBALSELL", VALUEFUNC(SecurityTradingStatus_MKTBALSELL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NEWPXIND", VALUEFUNC(SecurityTradingStatus_NEWPXIND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRDDISTIME", VALUEFUNC(SecurityTradingStatus_TRDDISTIME_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_PXIND", VALUEFUNC(SecurityTradingStatus_PXIND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_CROSS", VALUEFUNC(SecurityTradingStatus_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_OPENINGROTATION", VALUEFUNC(SecurityTradingStatus_OPENINGROTATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRDRNGIND", VALUEFUNC(SecurityTradingStatus_TRDRNGIND_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_RESUME", VALUEFUNC(SecurityTradingStatus_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRADE_DISSEMINATION_TIME", VALUEFUNC(SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE", VALUEFUNC(SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_POST_CLOSE", VALUEFUNC(SecurityTradingStatus_POST_CLOSE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_OPENDELAY", VALUEFUNC(SecurityTradingStatus_OPENDELAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_READY", VALUEFUNC(SecurityTradingStatus_READY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY", VALUEFUNC(SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOTAVAIL", VALUEFUNC(SecurityTradingStatus_NOTAVAIL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_IMBALANCE_SELL", VALUEFUNC(SecurityTradingStatus_MARKET_IMBALANCE_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_OPENING_DELAY", VALUEFUNC(SecurityTradingStatus_OPENING_DELAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MKTONCLSIMBSELL", VALUEFUNC(SecurityTradingStatus_MKTONCLSIMBSELL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET", VALUEFUNC(SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_ITS_PRE_OPENING", VALUEFUNC(SecurityTradingStatus_ITS_PRE_OPENING_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_PRE_CROSS", VALUEFUNC(SecurityTradingStatus_PRE_CROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NA", VALUEFUNC(SecurityTradingStatus_NA_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NOMKTONCLSIMB", VALUEFUNC(SecurityTradingStatus_NOMKTONCLSIMB_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_PRE_OPEN", VALUEFUNC(SecurityTradingStatus_PRE_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_IMBALANCE_BUY", VALUEFUNC(SecurityTradingStatus_MARKET_IMBALANCE_BUY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRADING_RANGE_INDICATION", VALUEFUNC(SecurityTradingStatus_TRADING_RANGE_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_READY_TO_TRADE", VALUEFUNC(SecurityTradingStatus_READY_TO_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NEW_PRICE_INDICATION", VALUEFUNC(SecurityTradingStatus_NEW_PRICE_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_ITSPREOPN", VALUEFUNC(SecurityTradingStatus_ITSPREOPN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_TRDHALT", VALUEFUNC(SecurityTradingStatus_TRDHALT_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MKTONCLSIMBBUY", VALUEFUNC(SecurityTradingStatus_MKTONCLSIMBBUY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_OPENING_ROTATION", VALUEFUNC(SecurityTradingStatus_OPENING_ROTATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_PRICE_INDICATION", VALUEFUNC(SecurityTradingStatus_PRICE_INDICATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_UNKNOWN_OR_INVALID", VALUEFUNC(SecurityTradingStatus_UNKNOWN_OR_INVALID_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL", VALUEFUNC(SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_UNKNOWN", VALUEFUNC(SecurityTradingStatus_UNKNOWN_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_MKTIMBBUY", VALUEFUNC(SecurityTradingStatus_MKTIMBBUY_get), 0);
  rb_define_singleton_method(mQuickfix, "SecurityTradingStatus_NO_MARKET_IMBALANCE", VALUEFUNC(SecurityTradingStatus_NO_MARKET_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGINDEXARBOTHMEM", VALUEFUNC(Rule80A_PRGINDEXARBOTHMEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER", VALUEFUNC(Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SPECIALIST_TRADES", VALUEFUNC(Rule80A_SPECIALIST_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER", VALUEFUNC(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(Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHTEXTRANI", VALUEFUNC(Rule80A_SHTEXTRANI_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHTEXTRANMEMWT", VALUEFUNC(Rule80A_SHTEXTRANMEMWT_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_F", VALUEFUNC(Rule80A_SHORT_EXEMPT_TRANSACTION_F_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPETING_DEALER_TRADES_O", VALUEFUNC(Rule80A_COMPETING_DEALER_TRADES_O_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER", VALUEFUNC(Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING", VALUEFUNC(Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHTEXTRANMEM", VALUEFUNC(Rule80A_SHTEXTRANMEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGINDEXARBOTHAGN", VALUEFUNC(Rule80A_PRGINDEXARBOTHAGN_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGNONINDEXARBINV", VALUEFUNC(Rule80A_PRGNONINDEXARBINV_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_H", VALUEFUNC(Rule80A_SHORT_EXEMPT_TRANSACTION_H_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRINCIPAL", VALUEFUNC(Rule80A_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_AGENCY_INDEX_ARBITRAGE", VALUEFUNC(Rule80A_AGENCY_INDEX_ARBITRAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER", VALUEFUNC(Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHTEXTRANA", VALUEFUNC(Rule80A_SHTEXTRANA_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHTEXTRANW", VALUEFUNC(Rule80A_SHTEXTRANW_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGINDEXARBINV", VALUEFUNC(Rule80A_PRGINDEXARBINV_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPETING_DEALER_TRADES_R", VALUEFUNC(Rule80A_COMPETING_DEALER_TRADES_R_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER", VALUEFUNC(Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE", VALUEFUNC(Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE", VALUEFUNC(Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_ALLOTHERAGN", VALUEFUNC(Rule80A_ALLOTHERAGN_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGNONINDEXARBOTHAGN", VALUEFUNC(Rule80A_PRGNONINDEXARBOTHAGN_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER", VALUEFUNC(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(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_AGENCYSINGLE", VALUEFUNC(Rule80A_AGENCYSINGLE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPETING_DEALER_TRADES_T", VALUEFUNC(Rule80A_COMPETING_DEALER_TRADES_T_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER", VALUEFUNC(Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING", VALUEFUNC(Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE", VALUEFUNC(Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGNONINDEXARBMEM", VALUEFUNC(Rule80A_PRGNONINDEXARBMEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGNONINDEXARBOTHMEM", VALUEFUNC(Rule80A_PRGNONINDEXARBOTHMEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER", VALUEFUNC(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(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(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(Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PRGINDEXARBMEM", VALUEFUNC(Rule80A_PRGINDEXARBMEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_INVINESTOR", VALUEFUNC(Rule80A_INVINESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL", VALUEFUNC(Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_B", VALUEFUNC(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(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(Rule80A_AGENCY_SINGLE_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE", VALUEFUNC(Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPETINGDEALER", VALUEFUNC(Rule80A_COMPETINGDEALER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPDEALER1", VALUEFUNC(Rule80A_COMPDEALER1_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SHTEXTRANNONMEM", VALUEFUNC(Rule80A_SHTEXTRANNONMEM_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER", VALUEFUNC(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(Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_MARKETMAKER", VALUEFUNC(Rule80A_MARKETMAKER_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_SPECIALIST", VALUEFUNC(Rule80A_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_COMPDEALER2", VALUEFUNC(Rule80A_COMPDEALER2_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY", VALUEFUNC(Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER", VALUEFUNC(Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_MERGER_REORGANIZATION", VALUEFUNC(CorporateAction_MERGER_REORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SYMBOL_CONVERSION", VALUEFUNC(CorporateAction_SYMBOL_CONVERSION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_NEW", VALUEFUNC(CorporateAction_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SUCCESSION_EVENT", VALUEFUNC(CorporateAction_SUCCESSION_EVENT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_STOCK_DIVIDEND", VALUEFUNC(CorporateAction_STOCK_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_REVERSE_STOCK_SPLIT", VALUEFUNC(CorporateAction_REVERSE_STOCK_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_POSITION_CONSOLIDATION", VALUEFUNC(CorporateAction_POSITION_CONSOLIDATION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SPINOFF", VALUEFUNC(CorporateAction_SPINOFF_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EXDIVIDEND", VALUEFUNC(CorporateAction_EXDIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_INTEREST", VALUEFUNC(CorporateAction_EX_INTEREST_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_LIQUIDATION_REORGANIZATION", VALUEFUNC(CorporateAction_LIQUIDATION_REORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_CASH_DIVIDEND", VALUEFUNC(CorporateAction_CASH_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_STANDARD_INTEGER_STOCK_SPLIT", VALUEFUNC(CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_RIGHTS_OFFERING", VALUEFUNC(CorporateAction_RIGHTS_OFFERING_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SHAREHOLDER_MEETING", VALUEFUNC(CorporateAction_SHAREHOLDER_MEETING_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_WARRANT", VALUEFUNC(CorporateAction_WARRANT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EXDIST", VALUEFUNC(CorporateAction_EXDIST_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_RIGHTS", VALUEFUNC(CorporateAction_EX_RIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_DISTRIBUTION", VALUEFUNC(CorporateAction_EX_DISTRIBUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EX_DIVIDEND", VALUEFUNC(CorporateAction_EX_DIVIDEND_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_TENDER_OFFER", VALUEFUNC(CorporateAction_TENDER_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_SPECIAL_ACTION", VALUEFUNC(CorporateAction_SPECIAL_ACTION_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EXINTEREST", VALUEFUNC(CorporateAction_EXINTEREST_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_NON_INTEGER_STOCK_SPLIT", VALUEFUNC(CorporateAction_NON_INTEGER_STOCK_SPLIT_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_CUSIP", VALUEFUNC(CorporateAction_CUSIP_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_LEAP_ROLLOVER", VALUEFUNC(CorporateAction_LEAP_ROLLOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "CorporateAction_EXRIGHTS", VALUEFUNC(CorporateAction_EXRIGHTS_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_TERM", VALUEFUNC(TerminationType_TERM_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_FLEXIBLE", VALUEFUNC(TerminationType_FLEXIBLE_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_OPEN", VALUEFUNC(TerminationType_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "TerminationType_OVERNIGHT", VALUEFUNC(TerminationType_OVERNIGHT_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_REPLACE", VALUEFUNC(PosMaintAction_REPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_NEW", VALUEFUNC(PosMaintAction_NEW_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_REVERSE", VALUEFUNC(PosMaintAction_REVERSE_get), 0);
  rb_define_singleton_method(mQuickfix, "PosMaintAction_CANCEL", VALUEFUNC(PosMaintAction_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceTimeType_SPECIFIED_DATE_TIME", VALUEFUNC(ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceTimeType_EXPIRATION", VALUEFUNC(ComplexEventPriceTimeType_EXPIRATION_get), 0);
  rb_define_singleton_method(mQuickfix, "ComplexEventPriceTimeType_IMMEDIATE", VALUEFUNC(ComplexEventPriceTimeType_IMMEDIATE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingFXRateCalc_DIVIDE", VALUEFUNC(UnderlyingFXRateCalc_DIVIDE_get), 0);
  rb_define_singleton_method(mQuickfix, "UnderlyingFXRateCalc_MULTIPLY", VALUEFUNC(UnderlyingFXRateCalc_MULTIPLY_get), 0);
  rb_define_singleton_method(mQuickfix, "OddLot_NO", VALUEFUNC(OddLot_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "OddLot_YES", VALUEFUNC(OddLot_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE", VALUEFUNC(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(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(BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_REJECTED_BY_INTERMEDIARY", VALUEFUNC(AllocStatus_REJECTED_BY_INTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED", VALUEFUNC(AllocStatus_ACCEPTEDSUCCESSFULLYPROCESSED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ACCOUNTLEVELREJECT", VALUEFUNC(AllocStatus_ACCOUNTLEVELREJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_BLOCK_LEVEL_REJECT", VALUEFUNC(AllocStatus_BLOCK_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ACCOUNT_LEVEL_REJECT", VALUEFUNC(AllocStatus_ACCOUNT_LEVEL_REJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_INCOMPLETE", VALUEFUNC(AllocStatus_INCOMPLETE_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ALLOCATION_PENDING", VALUEFUNC(AllocStatus_ALLOCATION_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_BLOCKLEVELREJECT", VALUEFUNC(AllocStatus_BLOCKLEVELREJECT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_REJECTEDBYINTERMEDIARY", VALUEFUNC(AllocStatus_REJECTEDBYINTERMEDIARY_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED", VALUEFUNC(AllocStatus_RECEIVEDRECEIVEDNOTYETPROCESSED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_REVERSED", VALUEFUNC(AllocStatus_REVERSED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_RECEIVED", VALUEFUNC(AllocStatus_RECEIVED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_PARTIAL_ACCEPT", VALUEFUNC(AllocStatus_PARTIAL_ACCEPT_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_REJECTED", VALUEFUNC(AllocStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "AllocStatus_ACCEPTED", VALUEFUNC(AllocStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "IncTaxInd_NET", VALUEFUNC(IncTaxInd_NET_get), 0);
  rb_define_singleton_method(mQuickfix, "IncTaxInd_GROSS", VALUEFUNC(IncTaxInd_GROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION", VALUEFUNC(PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES", VALUEFUNC(PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION", VALUEFUNC(PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES", VALUEFUNC(PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqStatus_COMPLETED", VALUEFUNC(PosReqStatus_COMPLETED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqStatus_REJECTED", VALUEFUNC(PosReqStatus_REJECTED_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqStatus_COMPLETEDWITHWARNINGS", VALUEFUNC(PosReqStatus_COMPLETEDWITHWARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "PosReqStatus_COMPLETED_WITH_WARNINGS", VALUEFUNC(PosReqStatus_COMPLETED_WITH_WARNINGS_get), 0);
  rb_define_singleton_method(mQuickfix, "PriorityIndicator_PRIORITY_UNCHANGED", VALUEFUNC(PriorityIndicator_PRIORITY_UNCHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "PriorityIndicator_PRIORITYUNCHANGED", VALUEFUNC(PriorityIndicator_PRIORITYUNCHANGED_get), 0);
  rb_define_singleton_method(mQuickfix, "PriorityIndicator_LOSTPRIORITY", VALUEFUNC(PriorityIndicator_LOSTPRIORITY_get), 0);
  rb_define_singleton_method(mQuickfix, "PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE", VALUEFUNC(PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_NOTCHECKED", VALUEFUNC(MoneyLaunderingStatus_NOTCHECKED_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT", VALUEFUNC(MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXAUTHCREDIT", VALUEFUNC(MoneyLaunderingStatus_EXAUTHCREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION", VALUEFUNC(MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION", VALUEFUNC(MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_NOT_CHECKED", VALUEFUNC(MoneyLaunderingStatus_NOT_CHECKED_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_PASSED", VALUEFUNC(MoneyLaunderingStatus_PASSED_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_1", VALUEFUNC(MoneyLaunderingStatus_EXEMPT_1_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXCLIENTMONEYTYPE", VALUEFUNC(MoneyLaunderingStatus_EXCLIENTMONEYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_2", VALUEFUNC(MoneyLaunderingStatus_EXEMPT_2_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXBELOWLIM", VALUEFUNC(MoneyLaunderingStatus_EXBELOWLIM_get), 0);
  rb_define_singleton_method(mQuickfix, "MoneyLaunderingStatus_EXEMPT_3", VALUEFUNC(MoneyLaunderingStatus_EXEMPT_3_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE", VALUEFUNC(LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_ROUND_LOT", VALUEFUNC(LotType_ROUND_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_ODD_LOT", VALUEFUNC(LotType_ODD_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "LotType_BLOCK_LOT", VALUEFUNC(LotType_BLOCK_LOT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FLAT_CURVE", VALUEFUNC(QuoteCondition_FLAT_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_REST_OF_BOOK_VWAP", VALUEFUNC(QuoteCondition_REST_OF_BOOK_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS", VALUEFUNC(QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_TRADING_RANGE", VALUEFUNC(QuoteCondition_TRADING_RANGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_HALT_ETH", VALUEFUNC(QuoteCondition_HALT_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_BID_OFFER_SPECIALIST", VALUEFUNC(QuoteCondition_BID_OFFER_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CONSOLBEST", VALUEFUNC(QuoteCondition_CONSOLBEST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CROSSED", VALUEFUNC(QuoteCondition_CROSSED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NO_OPEN", VALUEFUNC(QuoteCondition_NO_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_HALT", VALUEFUNC(QuoteCondition_HALT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_PREOPENING_SAM", VALUEFUNC(QuoteCondition_PREOPENING_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPEN_SAM", VALUEFUNC(QuoteCondition_OPEN_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_RESERVED_SAM", VALUEFUNC(QuoteCondition_RESERVED_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OUTRIGHT_PRICE", VALUEFUNC(QuoteCondition_OUTRIGHT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_IMPLIED_PRICE", VALUEFUNC(QuoteCondition_IMPLIED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DEPTH_ON_OFFER", VALUEFUNC(QuoteCondition_DEPTH_ON_OFFER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED", VALUEFUNC(QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_REGULAR_ETH", VALUEFUNC(QuoteCondition_REGULAR_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ROTATION_ETH", VALUEFUNC(QuoteCondition_ROTATION_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NONFIRM", VALUEFUNC(QuoteCondition_NONFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_EXCHANGE_BEST", VALUEFUNC(QuoteCondition_EXCHANGE_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DEPTH_ON_BID", VALUEFUNC(QuoteCondition_DEPTH_ON_BID_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CLOSING", VALUEFUNC(QuoteCondition_CLOSING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_VIEW_OF_COMMON", VALUEFUNC(QuoteCondition_VIEW_OF_COMMON_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FORBIDDEN_SAM", VALUEFUNC(QuoteCondition_FORBIDDEN_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_LOCKED", VALUEFUNC(QuoteCondition_LOCKED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ORDER_INFLUX", VALUEFUNC(QuoteCondition_ORDER_INFLUX_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NEWS_PENDING", VALUEFUNC(QuoteCondition_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_RESUME", VALUEFUNC(QuoteCondition_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_TRADING_RESUME", VALUEFUNC(QuoteCondition_TRADING_RESUME_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OUT_OF_SEQUENCE", VALUEFUNC(QuoteCondition_OUT_OF_SEQUENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_END_OF_DAY_SAM", VALUEFUNC(QuoteCondition_END_OF_DAY_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FROZEN_SAM", VALUEFUNC(QuoteCondition_FROZEN_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPENING_SAM", VALUEFUNC(QuoteCondition_OPENING_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_MANUAL_SLOW_QUOTE", VALUEFUNC(QuoteCondition_MANUAL_SLOW_QUOTE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NEWS_DISSEMINATION", VALUEFUNC(QuoteCondition_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DUE_TO_RELATED", VALUEFUNC(QuoteCondition_DUE_TO_RELATED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_VOLUME_ALERT", VALUEFUNC(QuoteCondition_VOLUME_ALERT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FAST_MARKET_ETH", VALUEFUNC(QuoteCondition_FAST_MARKET_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_INACTIVE_ETH", VALUEFUNC(QuoteCondition_INACTIVE_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DUE_TO_NEWS_DISSEMINATION", VALUEFUNC(QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_SURVEILLANCE_SAM", VALUEFUNC(QuoteCondition_SURVEILLANCE_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DEPTH", VALUEFUNC(QuoteCondition_DEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPEN", VALUEFUNC(QuoteCondition_OPEN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_AUTOMATIC_EXECUTION", VALUEFUNC(QuoteCondition_AUTOMATIC_EXECUTION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_DUE_TO_NEWS_PENDING", VALUEFUNC(QuoteCondition_DUE_TO_NEWS_PENDING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NO_ACTIVE_SAM", VALUEFUNC(QuoteCondition_NO_ACTIVE_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OFFER_SPECIALIST", VALUEFUNC(QuoteCondition_OFFER_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_SUSPENDED_SAM", VALUEFUNC(QuoteCondition_SUSPENDED_SAM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_RESTRICTED", VALUEFUNC(QuoteCondition_RESTRICTED_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_NON_FIRM", VALUEFUNC(QuoteCondition_NON_FIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CLOSED_INACTIVE", VALUEFUNC(QuoteCondition_CLOSED_INACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ADDITIONAL_INFO", VALUEFUNC(QuoteCondition_ADDITIONAL_INFO_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_EQUIPMENT_CHANGEOVER", VALUEFUNC(QuoteCondition_EQUIPMENT_CHANGEOVER_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_EXCHBEST", VALUEFUNC(QuoteCondition_EXCHBEST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FAST_TRADING", VALUEFUNC(QuoteCondition_FAST_TRADING_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FULL_CURVE", VALUEFUNC(QuoteCondition_FULL_CURVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_MEDIAN_PRICE", VALUEFUNC(QuoteCondition_MEDIAN_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_OPEN_ACTIVE", VALUEFUNC(QuoteCondition_OPEN_ACTIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ORDER_IMBALANCE", VALUEFUNC(QuoteCondition_ORDER_IMBALANCE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_AUTOMATIC_EXECUTION_ETH", VALUEFUNC(QuoteCondition_AUTOMATIC_EXECUTION_ETH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_ROTATION", VALUEFUNC(QuoteCondition_ROTATION_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_BID_SPECIALIST", VALUEFUNC(QuoteCondition_BID_SPECIALIST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_FAST", VALUEFUNC(QuoteCondition_FAST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CONSOLIDATED_BEST", VALUEFUNC(QuoteCondition_CONSOLIDATED_BEST_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteCondition_CLOSED", VALUEFUNC(QuoteCondition_CLOSED_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_OWNED_BY_30", VALUEFUNC(PartyRelationship_OWNED_BY_30_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_PROVIDES_QUOTES_TO", VALUEFUNC(PartyRelationship_PROVIDES_QUOTES_TO_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_POSTS_TRADES_TO", VALUEFUNC(PartyRelationship_POSTS_TRADES_TO_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_REGULATORY_OWNER_OF", VALUEFUNC(PartyRelationship_REGULATORY_OWNER_OF_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_SUBSIDIARY_OF", VALUEFUNC(PartyRelationship_SUBSIDIARY_OF_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_HAS_MEMBERS", VALUEFUNC(PartyRelationship_HAS_MEMBERS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_ENTERS_TRADES_THROUGH", VALUEFUNC(PartyRelationship_ENTERS_TRADES_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_BENEFICIAL_OWNER_OF", VALUEFUNC(PartyRelationship_BENEFICIAL_OWNER_OF_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_OWNED_BY_34", VALUEFUNC(PartyRelationship_OWNED_BY_34_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_CONTROLS", VALUEFUNC(PartyRelationship_CONTROLS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_REQUESTS_QUOTES_FROM", VALUEFUNC(PartyRelationship_REQUESTS_QUOTES_FROM_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_SPONSORS", VALUEFUNC(PartyRelationship_SPONSORS_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_CLEARS_THROUGH", VALUEFUNC(PartyRelationship_CLEARS_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_OWNED_BY_36", VALUEFUNC(PartyRelationship_OWNED_BY_36_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_BROKERS_TRADES_THROUGH", VALUEFUNC(PartyRelationship_BROKERS_TRADES_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_INVESTS_THROUGH", VALUEFUNC(PartyRelationship_INVESTS_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_PARTICIPANT_OF_MARKETPLACE", VALUEFUNC(PartyRelationship_PARTICIPANT_OF_MARKETPLACE_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_LEGAL", VALUEFUNC(PartyRelationship_LEGAL_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_ENTERS_TRADES_FOR", VALUEFUNC(PartyRelationship_ENTERS_TRADES_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_CARRIES_POSITIONS_FOR", VALUEFUNC(PartyRelationship_CARRIES_POSITIONS_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_IS_GUARANTEED_BY", VALUEFUNC(PartyRelationship_IS_GUARANTEED_BY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_IS_CONTROLLED_BY", VALUEFUNC(PartyRelationship_IS_CONTROLLED_BY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_PROVIDES_TRADING_SERVICES_FOR", VALUEFUNC(PartyRelationship_PROVIDES_TRADING_SERVICES_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_IS_ALSO", VALUEFUNC(PartyRelationship_IS_ALSO_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_PARENT_FIRM_FOR", VALUEFUNC(PartyRelationship_PARENT_FIRM_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_APPROVED_BY", VALUEFUNC(PartyRelationship_APPROVED_BY_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_APPROVES_OF", VALUEFUNC(PartyRelationship_APPROVES_OF_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_USES_TRADING_SERVICES_OF", VALUEFUNC(PartyRelationship_USES_TRADING_SERVICES_OF_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_PROVIDES_GUARANTEE_FOR", VALUEFUNC(PartyRelationship_PROVIDES_GUARANTEE_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_SPONSORED_THROUGH", VALUEFUNC(PartyRelationship_SPONSORED_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_TRADES_FOR", VALUEFUNC(PartyRelationship_TRADES_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_CLEARS_FOR", VALUEFUNC(PartyRelationship_CLEARS_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_BROKERS_TRADES_FOR", VALUEFUNC(PartyRelationship_BROKERS_TRADES_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_INVESTS_FOR", VALUEFUNC(PartyRelationship_INVESTS_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_PROVIDES_MARKETPLACE_FOR", VALUEFUNC(PartyRelationship_PROVIDES_MARKETPLACE_FOR_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_MEMBER_OF", VALUEFUNC(PartyRelationship_MEMBER_OF_get), 0);
  rb_define_singleton_method(mQuickfix, "PartyRelationship_TRADES_THROUGH", VALUEFUNC(PartyRelationship_TRADES_THROUGH_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_EUROCLEAR", VALUEFUNC(SettlLocation_EUROCLEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_CEDEL", VALUEFUNC(SettlLocation_CEDEL_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_PARTICIPANT_TRUST_COMPANY", VALUEFUNC(SettlLocation_PARTICIPANT_TRUST_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_PHYSICAL", VALUEFUNC(SettlLocation_PHYSICAL_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_EURO_CLEAR", VALUEFUNC(SettlLocation_EURO_CLEAR_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_FEDERALBOOKENTRY", VALUEFUNC(SettlLocation_FEDERALBOOKENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_PARTICIPANTTRUSTCOMPANY", VALUEFUNC(SettlLocation_PARTICIPANTTRUSTCOMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_DEPOSITORY_TRUST_COMPANY", VALUEFUNC(SettlLocation_DEPOSITORY_TRUST_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_DEPOSITORYTRUSTCOMPANY", VALUEFUNC(SettlLocation_DEPOSITORYTRUSTCOMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_LOCAL_MARKET_SETTLE_LOCATION", VALUEFUNC(SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_LOCALMARKETSETTLELOCATION", VALUEFUNC(SettlLocation_LOCALMARKETSETTLELOCATION_get), 0);
  rb_define_singleton_method(mQuickfix, "SettlLocation_FEDERAL_BOOK_ENTRY", VALUEFUNC(SettlLocation_FEDERAL_BOOK_ENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_LOCAL", VALUEFUNC(DiscretionScope_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_NATIONAL_EXCLUDING_LOCAL", VALUEFUNC(DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_NATIONALEXCLUDINGLOCAL", VALUEFUNC(DiscretionScope_NATIONALEXCLUDINGLOCAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_GLOBAL", VALUEFUNC(DiscretionScope_GLOBAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_NATIONAL", VALUEFUNC(DiscretionScope_NATIONAL_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionScope_LOCALEXCHANGEECNATS", VALUEFUNC(DiscretionScope_LOCALEXCHANGEECNATS_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NETWORKINGSUBACCT", VALUEFUNC(OwnerType_NETWORKINGSUBACCT_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PUBLIC_COMPANY", VALUEFUNC(OwnerType_PUBLIC_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_INDIVIDUAL_TRUSTEE", VALUEFUNC(OwnerType_INDIVIDUAL_TRUSTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT", VALUEFUNC(OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_INDIVIDUAL_INVESTOR", VALUEFUNC(OwnerType_INDIVIDUAL_INVESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_COMPANY_TRUSTEE", VALUEFUNC(OwnerType_COMPANY_TRUSTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_CORPBODY", VALUEFUNC(OwnerType_CORPBODY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_INDIVTRUSTEE", VALUEFUNC(OwnerType_INDIVTRUSTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PENSIONPLAN", VALUEFUNC(OwnerType_PENSIONPLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PRIVATE_COMPANY", VALUEFUNC(OwnerType_PRIVATE_COMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NETWORKING_SUB_ACCOUNT", VALUEFUNC(OwnerType_NETWORKING_SUB_ACCOUNT_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NON_PROFITORG", VALUEFUNC(OwnerType_NON_PROFITORG_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PRIVATECOMPANY", VALUEFUNC(OwnerType_PRIVATECOMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PENSION_PLAN", VALUEFUNC(OwnerType_PENSION_PLAN_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_COMPANYTRUSTEE", VALUEFUNC(OwnerType_COMPANYTRUSTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_TRUSTS", VALUEFUNC(OwnerType_TRUSTS_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_FIDUCIARIES", VALUEFUNC(OwnerType_FIDUCIARIES_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_INDIVINVESTOR", VALUEFUNC(OwnerType_INDIVINVESTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NON_PROFIT_ORGANIZATION", VALUEFUNC(OwnerType_NON_PROFIT_ORGANIZATION_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_CORPORATE_BODY", VALUEFUNC(OwnerType_CORPORATE_BODY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_PUBLICCOMPANY", VALUEFUNC(OwnerType_PUBLICCOMPANY_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_CUSTODIANMINORSACT", VALUEFUNC(OwnerType_CUSTODIANMINORSACT_get), 0);
  rb_define_singleton_method(mQuickfix, "OwnerType_NOMINEE", VALUEFUNC(OwnerType_NOMINEE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_END_SESSION", VALUEFUNC(ApplQueueResolution_END_SESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_QUEUEFLUSHED", VALUEFUNC(ApplQueueResolution_QUEUEFLUSHED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_QUEUE_FLUSHED", VALUEFUNC(ApplQueueResolution_QUEUE_FLUSHED_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_ENDSESSION", VALUEFUNC(ApplQueueResolution_ENDSESSION_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_OVERLAYLAST", VALUEFUNC(ApplQueueResolution_OVERLAYLAST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_OVERLAY_LAST", VALUEFUNC(ApplQueueResolution_OVERLAY_LAST_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_NOACTIONTAKEN", VALUEFUNC(ApplQueueResolution_NOACTIONTAKEN_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplQueueResolution_NO_ACTION_TAKEN", VALUEFUNC(ApplQueueResolution_NO_ACTION_TAKEN_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT", VALUEFUNC(QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKEACH", VALUEFUNC(QuoteResponseLevel_ACKEACH_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES", VALUEFUNC(QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKNEG", VALUEFUNC(QuoteResponseLevel_ACKNEG_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_NOACK", VALUEFUNC(QuoteResponseLevel_NOACK_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE", VALUEFUNC(QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES", VALUEFUNC(QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteResponseLevel_NO_ACKNOWLEDGEMENT", VALUEFUNC(QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecAckStatus_RECEIVED_NOT_YET_PROCESSED", VALUEFUNC(ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecAckStatus_DONT_KNOW", VALUEFUNC(ExecAckStatus_DONT_KNOW_get), 0);
  rb_define_singleton_method(mQuickfix, "ExecAckStatus_ACCEPTED", VALUEFUNC(ExecAckStatus_ACCEPTED_get), 0);
  rb_define_singleton_method(mQuickfix, "NetGrossInd_NET", VALUEFUNC(NetGrossInd_NET_get), 0);
  rb_define_singleton_method(mQuickfix, "NetGrossInd_GROSS", VALUEFUNC(NetGrossInd_GROSS_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlType_PARTIAL_CANCEL", VALUEFUNC(CxlType_PARTIAL_CANCEL_get), 0);
  rb_define_singleton_method(mQuickfix, "CxlType_FULL_REMAINING_QUANTITY", VALUEFUNC(CxlType_FULL_REMAINING_QUANTITY_get), 0);
  rb_define_singleton_method(mQuickfix, "DeskTypeSource_NASD_OATS", VALUEFUNC(DeskTypeSource_NASD_OATS_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MOREPASSIVE", VALUEFUNC(DiscretionRoundDirection_MOREPASSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MOREAGGRESSIVE", VALUEFUNC(DiscretionRoundDirection_MOREAGGRESSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MORE_AGGRESSIVE", VALUEFUNC(DiscretionRoundDirection_MORE_AGGRESSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionRoundDirection_MORE_PASSIVE", VALUEFUNC(DiscretionRoundDirection_MORE_PASSIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "BidDescriptorType_COUNTRY", VALUEFUNC(BidDescriptorType_COUNTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "BidDescriptorType_INDEX", VALUEFUNC(BidDescriptorType_INDEX_get), 0);
  rb_define_singleton_method(mQuickfix, "BidDescriptorType_SECTOR", VALUEFUNC(BidDescriptorType_SECTOR_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkStatusResponseType_INCREMENTAL_UPDATE", VALUEFUNC(NetworkStatusResponseType_INCREMENTAL_UPDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkStatusResponseType_INCREMENTALUPDATE", VALUEFUNC(NetworkStatusResponseType_INCREMENTALUPDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "NetworkStatusResponseType_FULL", VALUEFUNC(NetworkStatusResponseType_FULL_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_INDICATIVE", VALUEFUNC(QuoteType_INDICATIVE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_RESTRICTEDTRADEABLE", VALUEFUNC(QuoteType_RESTRICTEDTRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_RESTRICTED_TRADEABLE", VALUEFUNC(QuoteType_RESTRICTED_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_TRADEABLE", VALUEFUNC(QuoteType_TRADEABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "QuoteType_COUNTER", VALUEFUNC(QuoteType_COUNTER_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELVWAP", VALUEFUNC(DiscretionInst_RELVWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELLOCPRIMPX", VALUEFUNC(DiscretionInst_RELLOCPRIMPX_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_MARKET_PRICE", VALUEFUNC(DiscretionInst_RELATED_TO_MARKET_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELMIDPX", VALUEFUNC(DiscretionInst_RELMIDPX_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_VWAP", VALUEFUNC(DiscretionInst_RELATED_TO_VWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_MIDPOINT_PRICE", VALUEFUNC(DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELDISPPX", VALUEFUNC(DiscretionInst_RELDISPPX_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_DISPLAYED_PRICE", VALUEFUNC(DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_PRIMARY_PRICE", VALUEFUNC(DiscretionInst_RELATED_TO_PRIMARY_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_AVERAGE_PRICE_GUARANTEE", VALUEFUNC(DiscretionInst_AVERAGE_PRICE_GUARANTEE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELMKTPX", VALUEFUNC(DiscretionInst_RELMKTPX_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELPRIMPX", VALUEFUNC(DiscretionInst_RELPRIMPX_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELLSTPX", VALUEFUNC(DiscretionInst_RELLSTPX_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_LAST_TRADE_PRICE", VALUEFUNC(DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE", VALUEFUNC(DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_BUY_SIDE_IS_PRIORITIZED", VALUEFUNC(CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_SELL_SIDE_IS_PRIORITIZED", VALUEFUNC(CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_BUY_SIDE_PRIORITIZED", VALUEFUNC(CrossPrioritization_BUY_SIDE_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_SELL_SIDE_PRIORITIZED", VALUEFUNC(CrossPrioritization_SELL_SIDE_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_NONE", VALUEFUNC(CrossPrioritization_NONE_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_SELLSIDE_PRIORITIZED", VALUEFUNC(CrossPrioritization_SELLSIDE_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "CrossPrioritization_BUYSIDE_PRIORITIZED", VALUEFUNC(CrossPrioritization_BUYSIDE_PRIORITIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIOthSvc_AUTEX", VALUEFUNC(IOIOthSvc_AUTEX_get), 0);
  rb_define_singleton_method(mQuickfix, "IOIOthSvc_BRIDGE", VALUEFUNC(IOIOthSvc_BRIDGE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPSUB", VALUEFUNC(MDReqRejReason_UNSUPPSUB_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MDENTRYTYPE", VALUEFUNC(MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSUFFICIENT_CREDIT", VALUEFUNC(MDReqRejReason_INSUFFICIENT_CREDIT_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPMKTDEPTH", VALUEFUNC(MDReqRejReason_UNSUPPMKTDEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPENTRY", VALUEFUNC(MDReqRejReason_UNSUPPENTRY_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSUFFICIENT_BANDWIDTH", VALUEFUNC(MDReqRejReason_INSUFFICIENT_BANDWIDTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_SCOPE", VALUEFUNC(MDReqRejReason_UNSUPPORTED_SCOPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPMDIMPLICITDELETE", VALUEFUNC(MDReqRejReason_UNSUPPMDIMPLICITDELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID", VALUEFUNC(MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNKNOWNSYM", VALUEFUNC(MDReqRejReason_UNKNOWNSYM_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPMDUPDATE", VALUEFUNC(MDReqRejReason_UNSUPPMDUPDATE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG", VALUEFUNC(MDReqRejReason_UNSUPPPOSITIONEFFECTSETTLEFLAG_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_DUPLICATE_MDREQID", VALUEFUNC(MDReqRejReason_DUPLICATE_MDREQID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_DUPID", VALUEFUNC(MDReqRejReason_DUPID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK", VALUEFUNC(MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MDUPDATETYPE", VALUEFUNC(MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE", VALUEFUNC(MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNKNOWN_SYMBOL", VALUEFUNC(MDReqRejReason_UNKNOWN_SYMBOL_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSBAND", VALUEFUNC(MDReqRejReason_INSBAND_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPSCOPE", VALUEFUNC(MDReqRejReason_UNSUPPSCOPE_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG", VALUEFUNC(MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MARKETDEPTH", VALUEFUNC(MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPAGGBK", VALUEFUNC(MDReqRejReason_UNSUPPAGGBK_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSUFFICIENT_PERMISSIONS", VALUEFUNC(MDReqRejReason_INSUFFICIENT_PERMISSIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_INSPERM", VALUEFUNC(MDReqRejReason_INSPERM_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPTRDSESSIONID", VALUEFUNC(MDReqRejReason_UNSUPPTRDSESSIONID_get), 0);
  rb_define_singleton_method(mQuickfix, "MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE", VALUEFUNC(MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(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(ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS", VALUEFUNC(ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS", VALUEFUNC(ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_get), 0);
  rb_define_singleton_method(mQuickfix, "ApplReqType_CANCEL_RETRANSMISSION", VALUEFUNC(ApplReqType_CANCEL_RETRANSMISSION_get), 0);
  rb_define_singleton_method(mQuickfix, "AggressorIndicator_NO", VALUEFUNC(AggressorIndicator_NO_get), 0);
  rb_define_singleton_method(mQuickfix, "AggressorIndicator_YES", VALUEFUNC(AggressorIndicator_YES_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_APPNA", VALUEFUNC(BusinessRejectReason_APPNA_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_SECURITY", VALUEFUNC(BusinessRejectReason_UNKNOWN_SECURITY_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNMSGTYPE", VALUEFUNC(BusinessRejectReason_UNKNMSGTYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_CONDFLDMISS", VALUEFUNC(BusinessRejectReason_CONDFLDMISS_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNID", VALUEFUNC(BusinessRejectReason_UNKNID_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_APPLICATION_NOT_AVAILABLE", VALUEFUNC(BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_INVALID_PRICE_INCREMENT", VALUEFUNC(BusinessRejectReason_INVALID_PRICE_INCREMENT_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME", VALUEFUNC(BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING", VALUEFUNC(BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_ID", VALUEFUNC(BusinessRejectReason_UNKNOWN_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_NOTAUTH", VALUEFUNC(BusinessRejectReason_NOTAUTH_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_NODELIVTOFIRM", VALUEFUNC(BusinessRejectReason_NODELIVTOFIRM_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_OTHER", VALUEFUNC(BusinessRejectReason_OTHER_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE", VALUEFUNC(BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNOWN_MESSAGE_TYPE", VALUEFUNC(BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_NOT_AUTHORIZED", VALUEFUNC(BusinessRejectReason_NOT_AUTHORIZED_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKNSEC", VALUEFUNC(BusinessRejectReason_UNKNSEC_get), 0);
  rb_define_singleton_method(mQuickfix, "BusinessRejectReason_UNKOWN_ID", VALUEFUNC(BusinessRejectReason_UNKOWN_ID_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_REGULAR_BOOKING", VALUEFUNC(BookingType_REGULAR_BOOKING_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_REGULARBOOKING", VALUEFUNC(BookingType_REGULARBOOKING_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_CFD", VALUEFUNC(BookingType_CFD_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_CFDCONTRACTFORDIFFERENCE", VALUEFUNC(BookingType_CFDCONTRACTFORDIFFERENCE_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_TOTALRETURNSWAP", VALUEFUNC(BookingType_TOTALRETURNSWAP_get), 0);
  rb_define_singleton_method(mQuickfix, "BookingType_TOTAL_RETURN_SWAP", VALUEFUNC(BookingType_TOTAL_RETURN_SWAP_get), 0);
  
  cSessionID.klass = rb_define_class_under(mQuickfix, "SessionID", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionID, (void *) &cSessionID);
  rb_define_alloc_func(cSessionID.klass, _wrap_SessionID_allocate);
  rb_define_method(cSessionID.klass, "initialize", VALUEFUNC(_wrap_new_SessionID), -1);
  rb_define_method(cSessionID.klass, "getBeginString", VALUEFUNC(_wrap_SessionID_getBeginString), -1);
  rb_define_method(cSessionID.klass, "getSenderCompID", VALUEFUNC(_wrap_SessionID_getSenderCompID), -1);
  rb_define_method(cSessionID.klass, "getTargetCompID", VALUEFUNC(_wrap_SessionID_getTargetCompID), -1);
  rb_define_method(cSessionID.klass, "getSessionQualifier", VALUEFUNC(_wrap_SessionID_getSessionQualifier), -1);
  rb_define_method(cSessionID.klass, "isFIXT", VALUEFUNC(_wrap_SessionID_isFIXT), -1);
  rb_define_method(cSessionID.klass, "toStringFrozen", VALUEFUNC(_wrap_SessionID_toStringFrozen), -1);
  rb_define_method(cSessionID.klass, "fromString", VALUEFUNC(_wrap_SessionID_fromString), -1);
  rb_define_method(cSessionID.klass, "toString", VALUEFUNC(_wrap_SessionID_toString), -1);
  rb_define_method(cSessionID.klass, "~", VALUEFUNC(_wrap_SessionID___invert__), -1);
  rb_define_method(cSessionID.klass, "to_s", VALUEFUNC(_wrap_SessionID___str__), -1);
  cSessionID.mark = 0;
  cSessionID.destroy = (void (*)(void *)) free_FIX_SessionID;
  cSessionID.trackObjects = 0;
  rb_define_module_function(mQuickfix, "<", VALUEFUNC(_wrap___lt__), -1);
  rb_define_module_function(mQuickfix, "==", VALUEFUNC(_wrap___eq__), -1);
  
  cDictionary.klass = rb_define_class_under(mQuickfix, "Dictionary", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Dictionary, (void *) &cDictionary);
  rb_define_alloc_func(cDictionary.klass, _wrap_Dictionary_allocate);
  rb_define_method(cDictionary.klass, "initialize", VALUEFUNC(_wrap_new_Dictionary), -1);
  rb_define_method(cDictionary.klass, "getName", VALUEFUNC(_wrap_Dictionary_getName), -1);
  rb_define_method(cDictionary.klass, "size", VALUEFUNC(_wrap_Dictionary_size), -1);
  rb_define_method(cDictionary.klass, "getString", VALUEFUNC(_wrap_Dictionary_getString), -1);
  rb_define_method(cDictionary.klass, "getLong", VALUEFUNC(_wrap_Dictionary_getLong), -1);
  rb_define_method(cDictionary.klass, "getDouble", VALUEFUNC(_wrap_Dictionary_getDouble), -1);
  rb_define_method(cDictionary.klass, "getBool", VALUEFUNC(_wrap_Dictionary_getBool), -1);
  rb_define_method(cDictionary.klass, "getDay", VALUEFUNC(_wrap_Dictionary_getDay), -1);
  rb_define_method(cDictionary.klass, "setString", VALUEFUNC(_wrap_Dictionary_setString), -1);
  rb_define_method(cDictionary.klass, "setLong", VALUEFUNC(_wrap_Dictionary_setLong), -1);
  rb_define_method(cDictionary.klass, "setDouble", VALUEFUNC(_wrap_Dictionary_setDouble), -1);
  rb_define_method(cDictionary.klass, "setBool", VALUEFUNC(_wrap_Dictionary_setBool), -1);
  rb_define_method(cDictionary.klass, "setDay", VALUEFUNC(_wrap_Dictionary_setDay), -1);
  rb_define_method(cDictionary.klass, "has", VALUEFUNC(_wrap_Dictionary_has), -1);
  rb_define_method(cDictionary.klass, "merge", VALUEFUNC(_wrap_Dictionary_merge), -1);
  rb_define_method(cDictionary.klass, "begin", VALUEFUNC(_wrap_Dictionary_begin), -1);
  rb_define_method(cDictionary.klass, "end", VALUEFUNC(_wrap_Dictionary_end), -1);
  cDictionary.mark = 0;
  cDictionary.destroy = (void (*)(void *)) free_FIX_Dictionary;
  cDictionary.trackObjects = 0;
  rb_define_singleton_method(mQuickfix, "BEGINSTRING", VALUEFUNC(BEGINSTRING_get), 0);
  rb_define_singleton_method(mQuickfix, "SENDERCOMPID", VALUEFUNC(SENDERCOMPID_get), 0);
  rb_define_singleton_method(mQuickfix, "TARGETCOMPID", VALUEFUNC(TARGETCOMPID_get), 0);
  rb_define_singleton_method(mQuickfix, "SESSION_QUALIFIER", VALUEFUNC(SESSION_QUALIFIER_get), 0);
  rb_define_singleton_method(mQuickfix, "DEFAULT_APPLVERID", VALUEFUNC(DEFAULT_APPLVERID_get), 0);
  rb_define_singleton_method(mQuickfix, "CONNECTION_TYPE", VALUEFUNC(CONNECTION_TYPE_get), 0);
  rb_define_singleton_method(mQuickfix, "USE_DATA_DICTIONARY", VALUEFUNC(USE_DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "SEND_RESETSEQNUMFLAG", VALUEFUNC(SEND_RESETSEQNUMFLAG_get), 0);
  rb_define_singleton_method(mQuickfix, "SEND_REDUNDANT_RESENDREQUESTS", VALUEFUNC(SEND_REDUNDANT_RESENDREQUESTS_get), 0);
  rb_define_singleton_method(mQuickfix, "DATA_DICTIONARY", VALUEFUNC(DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "TRANSPORT_DATA_DICTIONARY", VALUEFUNC(TRANSPORT_DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "APP_DATA_DICTIONARY", VALUEFUNC(APP_DATA_DICTIONARY_get), 0);
  rb_define_singleton_method(mQuickfix, "USE_LOCAL_TIME", VALUEFUNC(USE_LOCAL_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "START_TIME", VALUEFUNC(START_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "END_TIME", VALUEFUNC(END_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "START_DAY", VALUEFUNC(START_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "END_DAY", VALUEFUNC(END_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGON_TIME", VALUEFUNC(LOGON_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGOUT_TIME", VALUEFUNC(LOGOUT_TIME_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGON_DAY", VALUEFUNC(LOGON_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGOUT_DAY", VALUEFUNC(LOGOUT_DAY_get), 0);
  rb_define_singleton_method(mQuickfix, "CHECK_COMPID", VALUEFUNC(CHECK_COMPID_get), 0);
  rb_define_singleton_method(mQuickfix, "CHECK_LATENCY", VALUEFUNC(CHECK_LATENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "MAX_LATENCY", VALUEFUNC(MAX_LATENCY_get), 0);
  rb_define_singleton_method(mQuickfix, "HEARTBTINT", VALUEFUNC(HEARTBTINT_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_ACCEPT_PORT", VALUEFUNC(SOCKET_ACCEPT_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_REUSE_ADDRESS", VALUEFUNC(SOCKET_REUSE_ADDRESS_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_CONNECT_HOST", VALUEFUNC(SOCKET_CONNECT_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_CONNECT_PORT", VALUEFUNC(SOCKET_CONNECT_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_NODELAY", VALUEFUNC(SOCKET_NODELAY_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_SEND_BUFFER_SIZE", VALUEFUNC(SOCKET_SEND_BUFFER_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "SOCKET_RECEIVE_BUFFER_SIZE", VALUEFUNC(SOCKET_RECEIVE_BUFFER_SIZE_get), 0);
  rb_define_singleton_method(mQuickfix, "RECONNECT_INTERVAL", VALUEFUNC(RECONNECT_INTERVAL_get), 0);
  rb_define_singleton_method(mQuickfix, "VALIDATE_FIELDS_OUT_OF_ORDER", VALUEFUNC(VALIDATE_FIELDS_OUT_OF_ORDER_get), 0);
  rb_define_singleton_method(mQuickfix, "VALIDATE_FIELDS_HAVE_VALUES", VALUEFUNC(VALIDATE_FIELDS_HAVE_VALUES_get), 0);
  rb_define_singleton_method(mQuickfix, "VALIDATE_USER_DEFINED_FIELDS", VALUEFUNC(VALIDATE_USER_DEFINED_FIELDS_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGON_TIMEOUT", VALUEFUNC(LOGON_TIMEOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "LOGOUT_TIMEOUT", VALUEFUNC(LOGOUT_TIMEOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "FILE_STORE_PATH", VALUEFUNC(FILE_STORE_PATH_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_USECONNECTIONPOOL", VALUEFUNC(MYSQL_STORE_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_DATABASE", VALUEFUNC(MYSQL_STORE_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_USER", VALUEFUNC(MYSQL_STORE_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_PASSWORD", VALUEFUNC(MYSQL_STORE_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_HOST", VALUEFUNC(MYSQL_STORE_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_STORE_PORT", VALUEFUNC(MYSQL_STORE_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_USECONNECTIONPOOL", VALUEFUNC(POSTGRESQL_STORE_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_DATABASE", VALUEFUNC(POSTGRESQL_STORE_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_USER", VALUEFUNC(POSTGRESQL_STORE_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_PASSWORD", VALUEFUNC(POSTGRESQL_STORE_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_HOST", VALUEFUNC(POSTGRESQL_STORE_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_STORE_PORT", VALUEFUNC(POSTGRESQL_STORE_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_STORE_USER", VALUEFUNC(ODBC_STORE_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_STORE_PASSWORD", VALUEFUNC(ODBC_STORE_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_STORE_CONNECTION_STRING", VALUEFUNC(ODBC_STORE_CONNECTION_STRING_get), 0);
  rb_define_singleton_method(mQuickfix, "FILE_LOG_PATH", VALUEFUNC(FILE_LOG_PATH_get), 0);
  rb_define_singleton_method(mQuickfix, "FILE_LOG_BACKUP_PATH", VALUEFUNC(FILE_LOG_BACKUP_PATH_get), 0);
  rb_define_singleton_method(mQuickfix, "SCREEN_LOG_SHOW_INCOMING", VALUEFUNC(SCREEN_LOG_SHOW_INCOMING_get), 0);
  rb_define_singleton_method(mQuickfix, "SCREEN_LOG_SHOW_OUTGOING", VALUEFUNC(SCREEN_LOG_SHOW_OUTGOING_get), 0);
  rb_define_singleton_method(mQuickfix, "SCREEN_LOG_SHOW_EVENTS", VALUEFUNC(SCREEN_LOG_SHOW_EVENTS_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_USECONNECTIONPOOL", VALUEFUNC(MYSQL_LOG_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_DATABASE", VALUEFUNC(MYSQL_LOG_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_USER", VALUEFUNC(MYSQL_LOG_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_PASSWORD", VALUEFUNC(MYSQL_LOG_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_HOST", VALUEFUNC(MYSQL_LOG_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_PORT", VALUEFUNC(MYSQL_LOG_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_INCOMING_TABLE", VALUEFUNC(MYSQL_LOG_INCOMING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_OUTGOING_TABLE", VALUEFUNC(MYSQL_LOG_OUTGOING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "MYSQL_LOG_EVENT_TABLE", VALUEFUNC(MYSQL_LOG_EVENT_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_USECONNECTIONPOOL", VALUEFUNC(POSTGRESQL_LOG_USECONNECTIONPOOL_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_DATABASE", VALUEFUNC(POSTGRESQL_LOG_DATABASE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_USER", VALUEFUNC(POSTGRESQL_LOG_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_PASSWORD", VALUEFUNC(POSTGRESQL_LOG_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_HOST", VALUEFUNC(POSTGRESQL_LOG_HOST_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_PORT", VALUEFUNC(POSTGRESQL_LOG_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_INCOMING_TABLE", VALUEFUNC(POSTGRESQL_LOG_INCOMING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_OUTGOING_TABLE", VALUEFUNC(POSTGRESQL_LOG_OUTGOING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "POSTGRESQL_LOG_EVENT_TABLE", VALUEFUNC(POSTGRESQL_LOG_EVENT_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_USER", VALUEFUNC(ODBC_LOG_USER_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_PASSWORD", VALUEFUNC(ODBC_LOG_PASSWORD_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_CONNECTION_STRING", VALUEFUNC(ODBC_LOG_CONNECTION_STRING_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_INCOMING_TABLE", VALUEFUNC(ODBC_LOG_INCOMING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_OUTGOING_TABLE", VALUEFUNC(ODBC_LOG_OUTGOING_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "ODBC_LOG_EVENT_TABLE", VALUEFUNC(ODBC_LOG_EVENT_TABLE_get), 0);
  rb_define_singleton_method(mQuickfix, "RESET_ON_LOGON", VALUEFUNC(RESET_ON_LOGON_get), 0);
  rb_define_singleton_method(mQuickfix, "RESET_ON_LOGOUT", VALUEFUNC(RESET_ON_LOGOUT_get), 0);
  rb_define_singleton_method(mQuickfix, "RESET_ON_DISCONNECT", VALUEFUNC(RESET_ON_DISCONNECT_get), 0);
  rb_define_singleton_method(mQuickfix, "REFRESH_ON_LOGON", VALUEFUNC(REFRESH_ON_LOGON_get), 0);
  rb_define_singleton_method(mQuickfix, "MILLISECONDS_IN_TIMESTAMP", VALUEFUNC(MILLISECONDS_IN_TIMESTAMP_get), 0);
  rb_define_singleton_method(mQuickfix, "HTTP_ACCEPT_PORT", VALUEFUNC(HTTP_ACCEPT_PORT_get), 0);
  rb_define_singleton_method(mQuickfix, "PERSIST_MESSAGES", VALUEFUNC(PERSIST_MESSAGES_get), 0);
  
  cSessionSettings.klass = rb_define_class_under(mQuickfix, "SessionSettings", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SessionSettings, (void *) &cSessionSettings);
  rb_define_alloc_func(cSessionSettings.klass, _wrap_SessionSettings_allocate);
  rb_define_method(cSessionSettings.klass, "initialize", VALUEFUNC(_wrap_new_SessionSettings), -1);
  rb_define_method(cSessionSettings.klass, "has", VALUEFUNC(_wrap_SessionSettings_has), -1);
  rb_define_method(cSessionSettings.klass, "get", VALUEFUNC(_wrap_SessionSettings_get), -1);
  rb_define_method(cSessionSettings.klass, "set", VALUEFUNC(_wrap_SessionSettings_set), -1);
  rb_define_method(cSessionSettings.klass, "size", VALUEFUNC(_wrap_SessionSettings_size), -1);
  rb_define_method(cSessionSettings.klass, "getSessions", VALUEFUNC(_wrap_SessionSettings_getSessions), -1);
  cSessionSettings.mark = 0;
  cSessionSettings.destroy = (void (*)(void *)) free_FIX_SessionSettings;
  cSessionSettings.trackObjects = 0;
  rb_define_module_function(mQuickfix, ">>", VALUEFUNC(_wrap___rshift__), -1);
  rb_define_module_function(mQuickfix, "<<", VALUEFUNC(_wrap___lshift__), -1);
  
  cSession.klass = rb_define_class_under(mQuickfix, "Session", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Session, (void *) &cSession);
  rb_define_alloc_func(cSession.klass, _wrap_Session_allocate);
  rb_define_method(cSession.klass, "initialize", VALUEFUNC(_wrap_new_Session), -1);
  rb_define_method(cSession.klass, "logon", VALUEFUNC(_wrap_Session_logon), -1);
  rb_define_method(cSession.klass, "logout", VALUEFUNC(_wrap_Session_logout), -1);
  rb_define_method(cSession.klass, "isEnabled", VALUEFUNC(_wrap_Session_isEnabled), -1);
  rb_define_method(cSession.klass, "sentLogon", VALUEFUNC(_wrap_Session_sentLogon), -1);
  rb_define_method(cSession.klass, "sentLogout", VALUEFUNC(_wrap_Session_sentLogout), -1);
  rb_define_method(cSession.klass, "receivedLogon", VALUEFUNC(_wrap_Session_receivedLogon), -1);
  rb_define_method(cSession.klass, "isLoggedOn", VALUEFUNC(_wrap_Session_isLoggedOn), -1);
  rb_define_method(cSession.klass, "reset", VALUEFUNC(_wrap_Session_reset), -1);
  rb_define_method(cSession.klass, "refresh", VALUEFUNC(_wrap_Session_refresh), -1);
  rb_define_method(cSession.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_Session_setNextSenderMsgSeqNum), -1);
  rb_define_method(cSession.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_Session_setNextTargetMsgSeqNum), -1);
  rb_define_method(cSession.klass, "getSessionID", VALUEFUNC(_wrap_Session_getSessionID), -1);
  rb_define_method(cSession.klass, "setDataDictionaryProvider", VALUEFUNC(_wrap_Session_setDataDictionaryProvider), -1);
  rb_define_method(cSession.klass, "getDataDictionaryProvider", VALUEFUNC(_wrap_Session_getDataDictionaryProvider), -1);
  rb_define_singleton_method(cSession.klass, "sendToTarget", VALUEFUNC(_wrap_Session_sendToTarget), -1);
  rb_define_singleton_method(cSession.klass, "getSessions", VALUEFUNC(_wrap_Session_getSessions), -1);
  rb_define_singleton_method(cSession.klass, "doesSessionExist", VALUEFUNC(_wrap_Session_doesSessionExist), -1);
  rb_define_singleton_method(cSession.klass, "lookupSession", VALUEFUNC(_wrap_Session_lookupSession), -1);
  rb_define_singleton_method(cSession.klass, "isSessionRegistered", VALUEFUNC(_wrap_Session_isSessionRegistered), -1);
  rb_define_singleton_method(cSession.klass, "registerSession", VALUEFUNC(_wrap_Session_registerSession), -1);
  rb_define_singleton_method(cSession.klass, "unregisterSession", VALUEFUNC(_wrap_Session_unregisterSession), -1);
  rb_define_singleton_method(cSession.klass, "numSessions", VALUEFUNC(_wrap_Session_numSessions), -1);
  rb_define_method(cSession.klass, "isSessionTime", VALUEFUNC(_wrap_Session_isSessionTime), -1);
  rb_define_method(cSession.klass, "isLogonTime", VALUEFUNC(_wrap_Session_isLogonTime), -1);
  rb_define_method(cSession.klass, "isInitiator", VALUEFUNC(_wrap_Session_isInitiator), -1);
  rb_define_method(cSession.klass, "isAcceptor", VALUEFUNC(_wrap_Session_isAcceptor), -1);
  rb_define_method(cSession.klass, "getLogonTime", VALUEFUNC(_wrap_Session_getLogonTime), -1);
  rb_define_method(cSession.klass, "setLogonTime", VALUEFUNC(_wrap_Session_setLogonTime), -1);
  rb_define_method(cSession.klass, "getSenderDefaultApplVerID", VALUEFUNC(_wrap_Session_getSenderDefaultApplVerID), -1);
  rb_define_method(cSession.klass, "setSenderDefaultApplVerID", VALUEFUNC(_wrap_Session_setSenderDefaultApplVerID), -1);
  rb_define_method(cSession.klass, "getTargetDefaultApplVerID", VALUEFUNC(_wrap_Session_getTargetDefaultApplVerID), -1);
  rb_define_method(cSession.klass, "setTargetDefaultApplVerID", VALUEFUNC(_wrap_Session_setTargetDefaultApplVerID), -1);
  rb_define_method(cSession.klass, "getSendRedundantResendRequests", VALUEFUNC(_wrap_Session_getSendRedundantResendRequests), -1);
  rb_define_method(cSession.klass, "setSendRedundantResendRequests", VALUEFUNC(_wrap_Session_setSendRedundantResendRequests), -1);
  rb_define_method(cSession.klass, "getCheckCompId", VALUEFUNC(_wrap_Session_getCheckCompId), -1);
  rb_define_method(cSession.klass, "setCheckCompId", VALUEFUNC(_wrap_Session_setCheckCompId), -1);
  rb_define_method(cSession.klass, "getCheckLatency", VALUEFUNC(_wrap_Session_getCheckLatency), -1);
  rb_define_method(cSession.klass, "setCheckLatency", VALUEFUNC(_wrap_Session_setCheckLatency), -1);
  rb_define_method(cSession.klass, "getMaxLatency", VALUEFUNC(_wrap_Session_getMaxLatency), -1);
  rb_define_method(cSession.klass, "setMaxLatency", VALUEFUNC(_wrap_Session_setMaxLatency), -1);
  rb_define_method(cSession.klass, "getLogonTimeout", VALUEFUNC(_wrap_Session_getLogonTimeout), -1);
  rb_define_method(cSession.klass, "setLogonTimeout", VALUEFUNC(_wrap_Session_setLogonTimeout), -1);
  rb_define_method(cSession.klass, "getLogoutTimeout", VALUEFUNC(_wrap_Session_getLogoutTimeout), -1);
  rb_define_method(cSession.klass, "setLogoutTimeout", VALUEFUNC(_wrap_Session_setLogoutTimeout), -1);
  rb_define_method(cSession.klass, "getResetOnLogon", VALUEFUNC(_wrap_Session_getResetOnLogon), -1);
  rb_define_method(cSession.klass, "setResetOnLogon", VALUEFUNC(_wrap_Session_setResetOnLogon), -1);
  rb_define_method(cSession.klass, "getResetOnLogout", VALUEFUNC(_wrap_Session_getResetOnLogout), -1);
  rb_define_method(cSession.klass, "setResetOnLogout", VALUEFUNC(_wrap_Session_setResetOnLogout), -1);
  rb_define_method(cSession.klass, "getResetOnDisconnect", VALUEFUNC(_wrap_Session_getResetOnDisconnect), -1);
  rb_define_method(cSession.klass, "setResetOnDisconnect", VALUEFUNC(_wrap_Session_setResetOnDisconnect), -1);
  rb_define_method(cSession.klass, "getRefreshOnLogon", VALUEFUNC(_wrap_Session_getRefreshOnLogon), -1);
  rb_define_method(cSession.klass, "setRefreshOnLogon", VALUEFUNC(_wrap_Session_setRefreshOnLogon), -1);
  rb_define_method(cSession.klass, "getMillisecondsInTimeStamp", VALUEFUNC(_wrap_Session_getMillisecondsInTimeStamp), -1);
  rb_define_method(cSession.klass, "setMillisecondsInTimeStamp", VALUEFUNC(_wrap_Session_setMillisecondsInTimeStamp), -1);
  rb_define_method(cSession.klass, "getPersistMessages", VALUEFUNC(_wrap_Session_getPersistMessages), -1);
  rb_define_method(cSession.klass, "setPersistMessages", VALUEFUNC(_wrap_Session_setPersistMessages), -1);
  rb_define_method(cSession.klass, "setResponder", VALUEFUNC(_wrap_Session_setResponder), -1);
  rb_define_method(cSession.klass, "send", VALUEFUNC(_wrap_Session_send), -1);
  rb_define_method(cSession.klass, "next", VALUEFUNC(_wrap_Session_next), -1);
  rb_define_method(cSession.klass, "disconnect", VALUEFUNC(_wrap_Session_disconnect), -1);
  rb_define_method(cSession.klass, "getExpectedSenderNum", VALUEFUNC(_wrap_Session_getExpectedSenderNum), -1);
  rb_define_method(cSession.klass, "getExpectedTargetNum", VALUEFUNC(_wrap_Session_getExpectedTargetNum), -1);
  rb_define_method(cSession.klass, "getLog", VALUEFUNC(_wrap_Session_getLog), -1);
  rb_define_method(cSession.klass, "getStore", VALUEFUNC(_wrap_Session_getStore), -1);
  cSession.mark = 0;
  cSession.destroy = (void (*)(void *)) free_FIX_Session;
  cSession.trackObjects = 0;
  
  cLogFactory.klass = rb_define_class_under(mQuickfix, "LogFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__LogFactory, (void *) &cLogFactory);
  rb_undef_alloc_func(cLogFactory.klass);
  rb_define_method(cLogFactory.klass, "create", VALUEFUNC(_wrap_LogFactory_create), -1);
  rb_define_method(cLogFactory.klass, "destroy", VALUEFUNC(_wrap_LogFactory_destroy), -1);
  cLogFactory.mark = 0;
  cLogFactory.destroy = (void (*)(void *)) free_FIX_LogFactory;
  cLogFactory.trackObjects = 0;
  
  cScreenLogFactory.klass = rb_define_class_under(mQuickfix, "ScreenLogFactory", ((swig_class *) SWIGTYPE_p_FIX__LogFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ScreenLogFactory, (void *) &cScreenLogFactory);
  rb_define_alloc_func(cScreenLogFactory.klass, _wrap_ScreenLogFactory_allocate);
  rb_define_method(cScreenLogFactory.klass, "initialize", VALUEFUNC(_wrap_new_ScreenLogFactory), -1);
  rb_define_method(cScreenLogFactory.klass, "create", VALUEFUNC(_wrap_ScreenLogFactory_create), -1);
  rb_define_method(cScreenLogFactory.klass, "destroy", VALUEFUNC(_wrap_ScreenLogFactory_destroy), -1);
  cScreenLogFactory.mark = 0;
  cScreenLogFactory.destroy = (void (*)(void *)) free_FIX_ScreenLogFactory;
  cScreenLogFactory.trackObjects = 0;
  
  cLog.klass = rb_define_class_under(mQuickfix, "Log", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Log, (void *) &cLog);
  rb_undef_alloc_func(cLog.klass);
  rb_define_method(cLog.klass, "clear", VALUEFUNC(_wrap_Log_clear), -1);
  rb_define_method(cLog.klass, "backup", VALUEFUNC(_wrap_Log_backup), -1);
  rb_define_method(cLog.klass, "onIncoming", VALUEFUNC(_wrap_Log_onIncoming), -1);
  rb_define_method(cLog.klass, "onOutgoing", VALUEFUNC(_wrap_Log_onOutgoing), -1);
  rb_define_method(cLog.klass, "onEvent", VALUEFUNC(_wrap_Log_onEvent), -1);
  cLog.mark = 0;
  cLog.destroy = (void (*)(void *)) free_FIX_Log;
  cLog.trackObjects = 0;
  
  cNullLog.klass = rb_define_class_under(mQuickfix, "NullLog", ((swig_class *) SWIGTYPE_p_FIX__Log->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NullLog, (void *) &cNullLog);
  rb_define_alloc_func(cNullLog.klass, _wrap_NullLog_allocate);
  rb_define_method(cNullLog.klass, "initialize", VALUEFUNC(_wrap_new_NullLog), -1);
  rb_define_method(cNullLog.klass, "clear", VALUEFUNC(_wrap_NullLog_clear), -1);
  rb_define_method(cNullLog.klass, "backup", VALUEFUNC(_wrap_NullLog_backup), -1);
  rb_define_method(cNullLog.klass, "onIncoming", VALUEFUNC(_wrap_NullLog_onIncoming), -1);
  rb_define_method(cNullLog.klass, "onOutgoing", VALUEFUNC(_wrap_NullLog_onOutgoing), -1);
  rb_define_method(cNullLog.klass, "onEvent", VALUEFUNC(_wrap_NullLog_onEvent), -1);
  cNullLog.mark = 0;
  cNullLog.destroy = (void (*)(void *)) free_FIX_NullLog;
  cNullLog.trackObjects = 0;
  
  cScreenLog.klass = rb_define_class_under(mQuickfix, "ScreenLog", ((swig_class *) SWIGTYPE_p_FIX__Log->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__ScreenLog, (void *) &cScreenLog);
  rb_define_alloc_func(cScreenLog.klass, _wrap_ScreenLog_allocate);
  rb_define_method(cScreenLog.klass, "initialize", VALUEFUNC(_wrap_new_ScreenLog), -1);
  rb_define_method(cScreenLog.klass, "clear", VALUEFUNC(_wrap_ScreenLog_clear), -1);
  rb_define_method(cScreenLog.klass, "backup", VALUEFUNC(_wrap_ScreenLog_backup), -1);
  rb_define_method(cScreenLog.klass, "onIncoming", VALUEFUNC(_wrap_ScreenLog_onIncoming), -1);
  rb_define_method(cScreenLog.klass, "onOutgoing", VALUEFUNC(_wrap_ScreenLog_onOutgoing), -1);
  rb_define_method(cScreenLog.klass, "onEvent", VALUEFUNC(_wrap_ScreenLog_onEvent), -1);
  rb_define_method(cScreenLog.klass, "getMillisecondsInTimeStamp", VALUEFUNC(_wrap_ScreenLog_getMillisecondsInTimeStamp), -1);
  rb_define_method(cScreenLog.klass, "setMillisecondsInTimeStamp", VALUEFUNC(_wrap_ScreenLog_setMillisecondsInTimeStamp), -1);
  cScreenLog.mark = 0;
  cScreenLog.destroy = (void (*)(void *)) free_FIX_ScreenLog;
  cScreenLog.trackObjects = 0;
  
  cFileLogFactory.klass = rb_define_class_under(mQuickfix, "FileLogFactory", ((swig_class *) SWIGTYPE_p_FIX__LogFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileLogFactory, (void *) &cFileLogFactory);
  rb_define_alloc_func(cFileLogFactory.klass, _wrap_FileLogFactory_allocate);
  rb_define_method(cFileLogFactory.klass, "initialize", VALUEFUNC(_wrap_new_FileLogFactory), -1);
  rb_define_method(cFileLogFactory.klass, "create", VALUEFUNC(_wrap_FileLogFactory_create), -1);
  rb_define_method(cFileLogFactory.klass, "destroy", VALUEFUNC(_wrap_FileLogFactory_destroy), -1);
  cFileLogFactory.mark = 0;
  cFileLogFactory.destroy = (void (*)(void *)) free_FIX_FileLogFactory;
  cFileLogFactory.trackObjects = 0;
  
  cFileLog.klass = rb_define_class_under(mQuickfix, "FileLog", ((swig_class *) SWIGTYPE_p_FIX__Log->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileLog, (void *) &cFileLog);
  rb_define_alloc_func(cFileLog.klass, _wrap_FileLog_allocate);
  rb_define_method(cFileLog.klass, "initialize", VALUEFUNC(_wrap_new_FileLog), -1);
  rb_define_method(cFileLog.klass, "clear", VALUEFUNC(_wrap_FileLog_clear), -1);
  rb_define_method(cFileLog.klass, "backup", VALUEFUNC(_wrap_FileLog_backup), -1);
  rb_define_method(cFileLog.klass, "onIncoming", VALUEFUNC(_wrap_FileLog_onIncoming), -1);
  rb_define_method(cFileLog.klass, "onOutgoing", VALUEFUNC(_wrap_FileLog_onOutgoing), -1);
  rb_define_method(cFileLog.klass, "onEvent", VALUEFUNC(_wrap_FileLog_onEvent), -1);
  rb_define_method(cFileLog.klass, "getMillisecondsInTimeStamp", VALUEFUNC(_wrap_FileLog_getMillisecondsInTimeStamp), -1);
  rb_define_method(cFileLog.klass, "setMillisecondsInTimeStamp", VALUEFUNC(_wrap_FileLog_setMillisecondsInTimeStamp), -1);
  cFileLog.mark = 0;
  cFileLog.destroy = (void (*)(void *)) free_FIX_FileLog;
  cFileLog.trackObjects = 0;
  
  cMessageStoreFactory.klass = rb_define_class_under(mQuickfix, "MessageStoreFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStoreFactory, (void *) &cMessageStoreFactory);
  rb_undef_alloc_func(cMessageStoreFactory.klass);
  rb_define_method(cMessageStoreFactory.klass, "create", VALUEFUNC(_wrap_MessageStoreFactory_create), -1);
  rb_define_method(cMessageStoreFactory.klass, "destroy", VALUEFUNC(_wrap_MessageStoreFactory_destroy), -1);
  cMessageStoreFactory.mark = 0;
  cMessageStoreFactory.destroy = (void (*)(void *)) free_FIX_MessageStoreFactory;
  cMessageStoreFactory.trackObjects = 0;
  
  cMemoryStoreFactory.klass = rb_define_class_under(mQuickfix, "MemoryStoreFactory", ((swig_class *) SWIGTYPE_p_FIX__MessageStoreFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MemoryStoreFactory, (void *) &cMemoryStoreFactory);
  rb_define_alloc_func(cMemoryStoreFactory.klass, _wrap_MemoryStoreFactory_allocate);
  rb_define_method(cMemoryStoreFactory.klass, "initialize", VALUEFUNC(_wrap_new_MemoryStoreFactory), -1);
  rb_define_method(cMemoryStoreFactory.klass, "create", VALUEFUNC(_wrap_MemoryStoreFactory_create), -1);
  rb_define_method(cMemoryStoreFactory.klass, "destroy", VALUEFUNC(_wrap_MemoryStoreFactory_destroy), -1);
  cMemoryStoreFactory.mark = 0;
  cMemoryStoreFactory.destroy = (void (*)(void *)) free_FIX_MemoryStoreFactory;
  cMemoryStoreFactory.trackObjects = 0;
  
  cMessageStore.klass = rb_define_class_under(mQuickfix, "MessageStore", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStore, (void *) &cMessageStore);
  rb_undef_alloc_func(cMessageStore.klass);
  rb_define_method(cMessageStore.klass, "set", VALUEFUNC(_wrap_MessageStore_set), -1);
  rb_define_method(cMessageStore.klass, "get", VALUEFUNC(_wrap_MessageStore_get), -1);
  rb_define_method(cMessageStore.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStore_getNextSenderMsgSeqNum), -1);
  rb_define_method(cMessageStore.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStore_getNextTargetMsgSeqNum), -1);
  rb_define_method(cMessageStore.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStore_setNextSenderMsgSeqNum), -1);
  rb_define_method(cMessageStore.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStore_setNextTargetMsgSeqNum), -1);
  rb_define_method(cMessageStore.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStore_incrNextSenderMsgSeqNum), -1);
  rb_define_method(cMessageStore.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStore_incrNextTargetMsgSeqNum), -1);
  rb_define_method(cMessageStore.klass, "getCreationTime", VALUEFUNC(_wrap_MessageStore_getCreationTime), -1);
  rb_define_method(cMessageStore.klass, "reset", VALUEFUNC(_wrap_MessageStore_reset), -1);
  rb_define_method(cMessageStore.klass, "refresh", VALUEFUNC(_wrap_MessageStore_refresh), -1);
  cMessageStore.mark = 0;
  cMessageStore.destroy = (void (*)(void *)) free_FIX_MessageStore;
  cMessageStore.trackObjects = 0;
  
  cMemoryStore.klass = rb_define_class_under(mQuickfix, "MemoryStore", ((swig_class *) SWIGTYPE_p_FIX__MessageStore->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MemoryStore, (void *) &cMemoryStore);
  rb_define_alloc_func(cMemoryStore.klass, _wrap_MemoryStore_allocate);
  rb_define_method(cMemoryStore.klass, "initialize", VALUEFUNC(_wrap_new_MemoryStore), -1);
  rb_define_method(cMemoryStore.klass, "set", VALUEFUNC(_wrap_MemoryStore_set), -1);
  rb_define_method(cMemoryStore.klass, "get", VALUEFUNC(_wrap_MemoryStore_get), -1);
  rb_define_method(cMemoryStore.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_getNextSenderMsgSeqNum), -1);
  rb_define_method(cMemoryStore.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_getNextTargetMsgSeqNum), -1);
  rb_define_method(cMemoryStore.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_setNextSenderMsgSeqNum), -1);
  rb_define_method(cMemoryStore.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_setNextTargetMsgSeqNum), -1);
  rb_define_method(cMemoryStore.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_incrNextSenderMsgSeqNum), -1);
  rb_define_method(cMemoryStore.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_MemoryStore_incrNextTargetMsgSeqNum), -1);
  rb_define_method(cMemoryStore.klass, "setCreationTime", VALUEFUNC(_wrap_MemoryStore_setCreationTime), -1);
  rb_define_method(cMemoryStore.klass, "getCreationTime", VALUEFUNC(_wrap_MemoryStore_getCreationTime), -1);
  rb_define_method(cMemoryStore.klass, "reset", VALUEFUNC(_wrap_MemoryStore_reset), -1);
  rb_define_method(cMemoryStore.klass, "refresh", VALUEFUNC(_wrap_MemoryStore_refresh), -1);
  cMemoryStore.mark = 0;
  cMemoryStore.destroy = (void (*)(void *)) free_FIX_MemoryStore;
  cMemoryStore.trackObjects = 0;
  
  cMessageStoreFactoryExceptionWrapper.klass = rb_define_class_under(mQuickfix, "MessageStoreFactoryExceptionWrapper", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, (void *) &cMessageStoreFactoryExceptionWrapper);
  rb_define_alloc_func(cMessageStoreFactoryExceptionWrapper.klass, _wrap_MessageStoreFactoryExceptionWrapper_allocate);
  rb_define_method(cMessageStoreFactoryExceptionWrapper.klass, "initialize", VALUEFUNC(_wrap_new_MessageStoreFactoryExceptionWrapper), -1);
  rb_define_method(cMessageStoreFactoryExceptionWrapper.klass, "create", VALUEFUNC(_wrap_MessageStoreFactoryExceptionWrapper_create), -1);
  rb_define_method(cMessageStoreFactoryExceptionWrapper.klass, "destroy", VALUEFUNC(_wrap_MessageStoreFactoryExceptionWrapper_destroy), -1);
  cMessageStoreFactoryExceptionWrapper.mark = 0;
  cMessageStoreFactoryExceptionWrapper.destroy = (void (*)(void *)) free_FIX_MessageStoreFactoryExceptionWrapper;
  cMessageStoreFactoryExceptionWrapper.trackObjects = 0;
  
  cMessageStoreExceptionWrapper.klass = rb_define_class_under(mQuickfix, "MessageStoreExceptionWrapper", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, (void *) &cMessageStoreExceptionWrapper);
  rb_define_alloc_func(cMessageStoreExceptionWrapper.klass, _wrap_MessageStoreExceptionWrapper_allocate);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "initialize", VALUEFUNC(_wrap_new_MessageStoreExceptionWrapper), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "set", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_set), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "get", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_get), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "getCreationTime", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_getCreationTime), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "reset", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_reset), -1);
  rb_define_method(cMessageStoreExceptionWrapper.klass, "refresh", VALUEFUNC(_wrap_MessageStoreExceptionWrapper_refresh), -1);
  cMessageStoreExceptionWrapper.mark = 0;
  cMessageStoreExceptionWrapper.destroy = (void (*)(void *)) free_FIX_MessageStoreExceptionWrapper;
  cMessageStoreExceptionWrapper.trackObjects = 0;
  
  cFileStoreFactory.klass = rb_define_class_under(mQuickfix, "FileStoreFactory", ((swig_class *) SWIGTYPE_p_FIX__MessageStoreFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileStoreFactory, (void *) &cFileStoreFactory);
  rb_define_alloc_func(cFileStoreFactory.klass, _wrap_FileStoreFactory_allocate);
  rb_define_method(cFileStoreFactory.klass, "initialize", VALUEFUNC(_wrap_new_FileStoreFactory), -1);
  rb_define_method(cFileStoreFactory.klass, "create", VALUEFUNC(_wrap_FileStoreFactory_create), -1);
  rb_define_method(cFileStoreFactory.klass, "destroy", VALUEFUNC(_wrap_FileStoreFactory_destroy), -1);
  cFileStoreFactory.mark = 0;
  cFileStoreFactory.destroy = (void (*)(void *)) free_FIX_FileStoreFactory;
  cFileStoreFactory.trackObjects = 0;
  
  cFileStore.klass = rb_define_class_under(mQuickfix, "FileStore", ((swig_class *) SWIGTYPE_p_FIX__MessageStore->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__FileStore, (void *) &cFileStore);
  rb_define_alloc_func(cFileStore.klass, _wrap_FileStore_allocate);
  rb_define_method(cFileStore.klass, "initialize", VALUEFUNC(_wrap_new_FileStore), -1);
  rb_define_method(cFileStore.klass, "set", VALUEFUNC(_wrap_FileStore_set), -1);
  rb_define_method(cFileStore.klass, "get", VALUEFUNC(_wrap_FileStore_get), -1);
  rb_define_method(cFileStore.klass, "getNextSenderMsgSeqNum", VALUEFUNC(_wrap_FileStore_getNextSenderMsgSeqNum), -1);
  rb_define_method(cFileStore.klass, "getNextTargetMsgSeqNum", VALUEFUNC(_wrap_FileStore_getNextTargetMsgSeqNum), -1);
  rb_define_method(cFileStore.klass, "setNextSenderMsgSeqNum", VALUEFUNC(_wrap_FileStore_setNextSenderMsgSeqNum), -1);
  rb_define_method(cFileStore.klass, "setNextTargetMsgSeqNum", VALUEFUNC(_wrap_FileStore_setNextTargetMsgSeqNum), -1);
  rb_define_method(cFileStore.klass, "incrNextSenderMsgSeqNum", VALUEFUNC(_wrap_FileStore_incrNextSenderMsgSeqNum), -1);
  rb_define_method(cFileStore.klass, "incrNextTargetMsgSeqNum", VALUEFUNC(_wrap_FileStore_incrNextTargetMsgSeqNum), -1);
  rb_define_method(cFileStore.klass, "getCreationTime", VALUEFUNC(_wrap_FileStore_getCreationTime), -1);
  rb_define_method(cFileStore.klass, "reset", VALUEFUNC(_wrap_FileStore_reset), -1);
  rb_define_method(cFileStore.klass, "refresh", VALUEFUNC(_wrap_FileStore_refresh), -1);
  cFileStore.mark = 0;
  cFileStore.destroy = (void (*)(void *)) free_FIX_FileStore;
  cFileStore.trackObjects = 0;
  rb_define_module_function(mQuickfix, "disown_Application", VALUEFUNC(_wrap_disown_Application), -1);
  
  cApplication.klass = rb_define_class_under(mQuickfix, "Application", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Application, (void *) &cApplication);
  rb_define_alloc_func(cApplication.klass, _wrap_Application_allocate);
  rb_define_method(cApplication.klass, "initialize", VALUEFUNC(_wrap_new_Application), -1);
  rb_define_method(cApplication.klass, "onCreate", VALUEFUNC(_wrap_Application_onCreate), -1);
  rb_define_method(cApplication.klass, "onLogon", VALUEFUNC(_wrap_Application_onLogon), -1);
  rb_define_method(cApplication.klass, "onLogout", VALUEFUNC(_wrap_Application_onLogout), -1);
  rb_define_method(cApplication.klass, "toAdmin", VALUEFUNC(_wrap_Application_toAdmin), -1);
  rb_define_method(cApplication.klass, "toApp", VALUEFUNC(_wrap_Application_toApp), -1);
  rb_define_method(cApplication.klass, "fromAdmin", VALUEFUNC(_wrap_Application_fromAdmin), -1);
  rb_define_method(cApplication.klass, "fromApp", VALUEFUNC(_wrap_Application_fromApp), -1);
  cApplication.mark = 0;
  cApplication.destroy = (void (*)(void *)) free_FIX_Application;
  cApplication.trackObjects = 0;
  
  cSynchronizedApplication.klass = rb_define_class_under(mQuickfix, "SynchronizedApplication", ((swig_class *) SWIGTYPE_p_FIX__Application->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SynchronizedApplication, (void *) &cSynchronizedApplication);
  rb_define_alloc_func(cSynchronizedApplication.klass, _wrap_SynchronizedApplication_allocate);
  rb_define_method(cSynchronizedApplication.klass, "initialize", VALUEFUNC(_wrap_new_SynchronizedApplication), -1);
  rb_define_method(cSynchronizedApplication.klass, "onCreate", VALUEFUNC(_wrap_SynchronizedApplication_onCreate), -1);
  rb_define_method(cSynchronizedApplication.klass, "onLogon", VALUEFUNC(_wrap_SynchronizedApplication_onLogon), -1);
  rb_define_method(cSynchronizedApplication.klass, "onLogout", VALUEFUNC(_wrap_SynchronizedApplication_onLogout), -1);
  rb_define_method(cSynchronizedApplication.klass, "toAdmin", VALUEFUNC(_wrap_SynchronizedApplication_toAdmin), -1);
  rb_define_method(cSynchronizedApplication.klass, "toApp", VALUEFUNC(_wrap_SynchronizedApplication_toApp), -1);
  rb_define_method(cSynchronizedApplication.klass, "fromAdmin", VALUEFUNC(_wrap_SynchronizedApplication_fromAdmin), -1);
  rb_define_method(cSynchronizedApplication.klass, "fromApp", VALUEFUNC(_wrap_SynchronizedApplication_fromApp), -1);
  rb_define_method(cSynchronizedApplication.klass, "m_mutex=", VALUEFUNC(_wrap_SynchronizedApplication_m_mutex_set), -1);
  rb_define_method(cSynchronizedApplication.klass, "m_mutex", VALUEFUNC(_wrap_SynchronizedApplication_m_mutex_get), -1);
  rb_define_method(cSynchronizedApplication.klass, "app", VALUEFUNC(_wrap_SynchronizedApplication_app), -1);
  rb_define_method(cSynchronizedApplication.klass, "m_app=", VALUEFUNC(_wrap_SynchronizedApplication_m_app_set), -1);
  rb_define_method(cSynchronizedApplication.klass, "m_app", VALUEFUNC(_wrap_SynchronizedApplication_m_app_get), -1);
  cSynchronizedApplication.mark = 0;
  cSynchronizedApplication.destroy = (void (*)(void *)) free_FIX_SynchronizedApplication;
  cSynchronizedApplication.trackObjects = 0;
  
  cNullApplication.klass = rb_define_class_under(mQuickfix, "NullApplication", ((swig_class *) SWIGTYPE_p_FIX__Application->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__NullApplication, (void *) &cNullApplication);
  rb_define_alloc_func(cNullApplication.klass, _wrap_NullApplication_allocate);
  rb_define_method(cNullApplication.klass, "initialize", VALUEFUNC(_wrap_new_NullApplication), -1);
  cNullApplication.mark = 0;
  cNullApplication.destroy = (void (*)(void *)) free_FIX_NullApplication;
  cNullApplication.trackObjects = 0;
  
  cInitiator.klass = rb_define_class_under(mQuickfix, "Initiator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Initiator, (void *) &cInitiator);
  rb_undef_alloc_func(cInitiator.klass);
  rb_define_method(cInitiator.klass, "start", VALUEFUNC(_wrap_Initiator_start), -1);
  rb_define_method(cInitiator.klass, "block", VALUEFUNC(_wrap_Initiator_block), -1);
  rb_define_method(cInitiator.klass, "poll", VALUEFUNC(_wrap_Initiator_poll), -1);
  rb_define_method(cInitiator.klass, "stop", VALUEFUNC(_wrap_Initiator_stop), -1);
  rb_define_method(cInitiator.klass, "isLoggedOn", VALUEFUNC(_wrap_Initiator_isLoggedOn), -1);
  rb_define_method(cInitiator.klass, "getSessions", VALUEFUNC(_wrap_Initiator_getSessions), -1);
  rb_define_method(cInitiator.klass, "getSession", VALUEFUNC(_wrap_Initiator_getSession), -1);
  rb_define_method(cInitiator.klass, "getSessionSettings", VALUEFUNC(_wrap_Initiator_getSessionSettings), -1);
  rb_define_method(cInitiator.klass, "has", VALUEFUNC(_wrap_Initiator_has), -1);
  rb_define_method(cInitiator.klass, "isStopped", VALUEFUNC(_wrap_Initiator_isStopped), -1);
  rb_define_method(cInitiator.klass, "getApplication", VALUEFUNC(_wrap_Initiator_getApplication), -1);
  rb_define_method(cInitiator.klass, "getMessageStoreFactory", VALUEFUNC(_wrap_Initiator_getMessageStoreFactory), -1);
  rb_define_method(cInitiator.klass, "getLog", VALUEFUNC(_wrap_Initiator_getLog), -1);
  cInitiator.mark = 0;
  cInitiator.destroy = (void (*)(void *)) free_FIX_Initiator;
  cInitiator.trackObjects = 0;
  
  cSocketInitiatorBase.klass = rb_define_class_under(mQuickfix, "SocketInitiatorBase", ((swig_class *) SWIGTYPE_p_FIX__Initiator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketInitiator, (void *) &cSocketInitiatorBase);
  rb_define_alloc_func(cSocketInitiatorBase.klass, _wrap_SocketInitiatorBase_allocate);
  rb_define_method(cSocketInitiatorBase.klass, "initialize", VALUEFUNC(_wrap_new_SocketInitiatorBase), -1);
  cSocketInitiatorBase.mark = 0;
  cSocketInitiatorBase.destroy = (void (*)(void *)) free_FIX_SocketInitiator;
  cSocketInitiatorBase.trackObjects = 0;
  
  cAcceptor.klass = rb_define_class_under(mQuickfix, "Acceptor", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__Acceptor, (void *) &cAcceptor);
  rb_undef_alloc_func(cAcceptor.klass);
  rb_define_method(cAcceptor.klass, "getLog", VALUEFUNC(_wrap_Acceptor_getLog), -1);
  rb_define_method(cAcceptor.klass, "start", VALUEFUNC(_wrap_Acceptor_start), -1);
  rb_define_method(cAcceptor.klass, "block", VALUEFUNC(_wrap_Acceptor_block), -1);
  rb_define_method(cAcceptor.klass, "poll", VALUEFUNC(_wrap_Acceptor_poll), -1);
  rb_define_method(cAcceptor.klass, "stop", VALUEFUNC(_wrap_Acceptor_stop), -1);
  rb_define_method(cAcceptor.klass, "isLoggedOn", VALUEFUNC(_wrap_Acceptor_isLoggedOn), -1);
  rb_define_method(cAcceptor.klass, "getSessions", VALUEFUNC(_wrap_Acceptor_getSessions), -1);
  rb_define_method(cAcceptor.klass, "getSession", VALUEFUNC(_wrap_Acceptor_getSession), -1);
  rb_define_method(cAcceptor.klass, "getSessionSettings", VALUEFUNC(_wrap_Acceptor_getSessionSettings), -1);
  rb_define_method(cAcceptor.klass, "has", VALUEFUNC(_wrap_Acceptor_has), -1);
  rb_define_method(cAcceptor.klass, "isStopped", VALUEFUNC(_wrap_Acceptor_isStopped), -1);
  rb_define_method(cAcceptor.klass, "getApplication", VALUEFUNC(_wrap_Acceptor_getApplication), -1);
  rb_define_method(cAcceptor.klass, "getMessageStoreFactory", VALUEFUNC(_wrap_Acceptor_getMessageStoreFactory), -1);
  cAcceptor.mark = 0;
  cAcceptor.destroy = (void (*)(void *)) free_FIX_Acceptor;
  cAcceptor.trackObjects = 0;
  
  cSocketAcceptorBase.klass = rb_define_class_under(mQuickfix, "SocketAcceptorBase", ((swig_class *) SWIGTYPE_p_FIX__Acceptor->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__SocketAcceptor, (void *) &cSocketAcceptorBase);
  rb_define_alloc_func(cSocketAcceptorBase.klass, _wrap_SocketAcceptorBase_allocate);
  rb_define_method(cSocketAcceptorBase.klass, "initialize", VALUEFUNC(_wrap_new_SocketAcceptorBase), -1);
  cSocketAcceptorBase.mark = 0;
  cSocketAcceptorBase.destroy = (void (*)(void *)) free_FIX_SocketAcceptor;
  cSocketAcceptorBase.trackObjects = 0;
  
  cDataDictionary.klass = rb_define_class_under(mQuickfix, "DataDictionary", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_FIX__DataDictionary, (void *) &cDataDictionary);
  rb_define_alloc_func(cDataDictionary.klass, _wrap_DataDictionary_allocate);
  rb_define_method(cDataDictionary.klass, "initialize", VALUEFUNC(_wrap_new_DataDictionary), -1);
  rb_define_method(cDataDictionary.klass, "readFromURL", VALUEFUNC(_wrap_DataDictionary_readFromURL), -1);
  rb_define_method(cDataDictionary.klass, "readFromDocument", VALUEFUNC(_wrap_DataDictionary_readFromDocument), -1);
  rb_define_method(cDataDictionary.klass, "readFromStream", VALUEFUNC(_wrap_DataDictionary_readFromStream), -1);
  rb_define_method(cDataDictionary.klass, "getOrderedFields", VALUEFUNC(_wrap_DataDictionary_getOrderedFields), -1);
  rb_define_method(cDataDictionary.klass, "setVersion", VALUEFUNC(_wrap_DataDictionary_setVersion), -1);
  rb_define_method(cDataDictionary.klass, "getVersion", VALUEFUNC(_wrap_DataDictionary_getVersion), -1);
  rb_define_method(cDataDictionary.klass, "addField", VALUEFUNC(_wrap_DataDictionary_addField), -1);
  rb_define_method(cDataDictionary.klass, "addFieldName", VALUEFUNC(_wrap_DataDictionary_addFieldName), -1);
  rb_define_method(cDataDictionary.klass, "_getFieldName", VALUEFUNC(_wrap_DataDictionary__getFieldName), -1);
  rb_define_method(cDataDictionary.klass, "_getFieldTag", VALUEFUNC(_wrap_DataDictionary__getFieldTag), -1);
  rb_define_method(cDataDictionary.klass, "addValueName", VALUEFUNC(_wrap_DataDictionary_addValueName), -1);
  rb_define_method(cDataDictionary.klass, "_getValueName", VALUEFUNC(_wrap_DataDictionary__getValueName), -1);
  rb_define_method(cDataDictionary.klass, "isField", VALUEFUNC(_wrap_DataDictionary_isField), -1);
  rb_define_method(cDataDictionary.klass, "addMsgType", VALUEFUNC(_wrap_DataDictionary_addMsgType), -1);
  rb_define_method(cDataDictionary.klass, "isMsgType", VALUEFUNC(_wrap_DataDictionary_isMsgType), -1);
  rb_define_method(cDataDictionary.klass, "addMsgField", VALUEFUNC(_wrap_DataDictionary_addMsgField), -1);
  rb_define_method(cDataDictionary.klass, "isMsgField", VALUEFUNC(_wrap_DataDictionary_isMsgField), -1);
  rb_define_method(cDataDictionary.klass, "addHeaderField", VALUEFUNC(_wrap_DataDictionary_addHeaderField), -1);
  rb_define_method(cDataDictionary.klass, "isHeaderField", VALUEFUNC(_wrap_DataDictionary_isHeaderField), -1);
  rb_define_method(cDataDictionary.klass, "addTrailerField", VALUEFUNC(_wrap_DataDictionary_addTrailerField), -1);
  rb_define_method(cDataDictionary.klass, "isTrailerField", VALUEFUNC(_wrap_DataDictionary_isTrailerField), -1);
  rb_define_method(cDataDictionary.klass, "addFieldType", VALUEFUNC(_wrap_DataDictionary_addFieldType), -1);
  rb_define_method(cDataDictionary.klass, "getFieldType", VALUEFUNC(_wrap_DataDictionary_getFieldType), -1);
  rb_define_method(cDataDictionary.klass, "addRequiredField", VALUEFUNC(_wrap_DataDictionary_addRequiredField), -1);
  rb_define_method(cDataDictionary.klass, "isRequiredField", VALUEFUNC(_wrap_DataDictionary_isRequiredField), -1);
  rb_define_method(cDataDictionary.klass, "addFieldValue", VALUEFUNC(_wrap_DataDictionary_addFieldValue), -1);
  rb_define_method(cDataDictionary.klass, "hasFieldValue", VALUEFUNC(_wrap_DataDictionary_hasFieldValue), -1);
  rb_define_method(cDataDictionary.klass, "isFieldValue", VALUEFUNC(_wrap_DataDictionary_isFieldValue), -1);
  rb_define_method(cDataDictionary.klass, "addGroup", VALUEFUNC(_wrap_DataDictionary_addGroup), -1);
  rb_define_method(cDataDictionary.klass, "isGroup", VALUEFUNC(_wrap_DataDictionary_isGroup), -1);
  rb_define_method(cDataDictionary.klass, "_getGroup", VALUEFUNC(_wrap_DataDictionary__getGroup), -1);
  rb_define_method(cDataDictionary.klass, "isDataField", VALUEFUNC(_wrap_DataDictionary_isDataField), -1);
  rb_define_method(cDataDictionary.klass, "isMultipleValueField", VALUEFUNC(_wrap_DataDictionary_isMultipleValueField), -1);
  rb_define_method(cDataDictionary.klass, "checkFieldsOutOfOrder", VALUEFUNC(_wrap_DataDictionary_checkFieldsOutOfOrder), -1);
  rb_define_method(cDataDictionary.klass, "checkFieldsHaveValues", VALUEFUNC(_wrap_DataDictionary_checkFieldsHaveValues), -1);
  rb_define_method(cDataDictionary.klass, "checkUserDefinedFields", VALUEFUNC(_wrap_DataDictionary_checkUserDefinedFields), -1);
  rb_define_method(cDataDictionary.klass, "validate", VALUEFUNC(_wrap_DataDictionary_validate), -1);
  cDataDictionary.mark = 0;
  cDataDictionary.destroy = (void (*)(void *)) free_FIX_DataDictionary;
  cDataDictionary.trackObjects = 0;
}

